Operations | Monitoring | ITSM | DevOps | Cloud

AI finds vulnerabilities faster than you can fix them

If an AI model can find a vulnerability for an attacker, the same model should help a defender fix it. In practice, the math doesn't favor the defender. This quick video digs into the real asymmetry AI-powered vulnerability discovery creates: The goal is models acting as tools for defenders, not weapons for attackers. Getting there means rethinking how much ground your team can realistically cover on its own.

MCP vs API: How they work together and when to use each

Summary: An API defines how software interacts with a service. MCP defines a standard way for AI applications to discover and invoke tools exposed by a service. They usually work together: an MCP server can sit in front of APIs you already run, turning low-level operations into capabilities an agent can find and use at runtime. Your API may already expose everything an AI agent needs. The harder problem is helping the agent figure out which operations matter for the task it has been given.

Don't Break the Agent: Lessons in Token Optimization

This one is for the curious souls who wonder how somebody actually builds a harness optimizer — and, more to the point, how they know it works. When we launched JFrog Boost into public preview, we told the story of the bill that broke us and the 100 billion tokens we clawed back across JFrog R&D. What that post didn’t cover is the question that consumed most of our engineering time: how do you measure any of this?

Why artifact management can't stop at npm and Python

npm and Python get all the security attention, but attackers don't limit themselves to your highest-volume formats. A Docker image, a Helm chart, or a Rust crate can all be an entry point. If your security policy is built around the formats you use most, the formats you've deprioritized become the blind spot. This video breaks down why artifact management needs to be centralized across every package format, not just the popular ones.

JFrog Artifactory Now Integrates Natively with Artifact Registry in Google Cloud

Teams running containerized workloads on Google Cloud have long relied on JFrog as their single source of truth for container images. The missing piece has been getting Google Cloud’s own runtime services — like Cloud Run and Google Kubernetes Engine (GKE) — to pull directly from JFrog for every container image pull. I’m happy to say that the gap is now closed. Artifact Registry in Google Cloud has introduced a new repository mode called Connector that addresses this requirement.

Argo CD Deployment Failed: AI SRE Agent AURA Finds and Fixes It

A deployment fails validation and the sync stops. Argo CD hands the report to AURA, which finds the wrong version, fixes it, and re-runs the sync. Normally, a failed sync means a person opens the application, reads the hook logs, and works out which value is wrong. Here, the sync fail hook sends AURA a short failure report and an incident ID over the agent-to-agent protocol, then exits. It does not say how to investigate or what to change.

AGENTS.md vs. skills: How to steer a coding agent

Every team adopting coding agents hits the same question early: where do you put the instructions that tell the agent how your codebase actually works? Two answers dominate the conversation right now. One is AGENTS.md, a plain markdown file at the root of your repo. The other is skills, packaged instruction sets an agent loads on demand. Most of the debate treats this as a formatting decision. It isn’t.

Starting your engineering career in the AI era: 6 takeaways for junior developers

“We don’t need junior engineers anymore” has become one of those lines people repeat because it sounds obvious. The AI writes the code, so why pay someone to learn how to write it? On the latest Confident Commit podcast, Rob Zuber makes the case that this take is exactly backwards.

DevOps Cost of Ignoring Bad Bots on Your Infrastructure

A traffic spike used to mean good news. Now, it's just as likely to mean a scraper found your pricing page or a credential-stuffing script started hammering your login endpoint at 3 a.m. Most teams treat this as a security problem and hand it off accordingly. That's a mistake, because by the time it reaches security, it has already cost engineering time, compute budget, and a fair amount of sleep.

Introducing the redesigned deployments experience

You shouldn’t have to hunt through a cluttered dashboard to understand where your code is deployed. The Deployments page is where teams turn for a quick answer: what is in test, what is in staging, what reached production, and what needs attention right now. The older page made that harder than it needed to be. Our new Pipelines Deployments page makes it easier to scan, filter, and act on.

Peer Review: CircleCI's CFO & CMO on What Comes After AI Code Generation

Last year was the year of AI code generation. This year is everything that comes after: validation, quality, and making sure what gets built actually ships. Nobody's better positioned to talk about that than CircleCI, and in this episode of Peer Review, CFO Blake Buisson and CMO Chitra Balasubramanian dig into what that moment means for the company and the people building it.

Peer Review: CircleCI's CRO & CLO on the Skill of Learning Fast

Seven years of institutional knowledge meets a fresh outside perspective in this episode of Peer Review. June Ko is CircleCI's Chief Legal Officer. Judson Griffin is the Chief Revenue Officer. They cover what tenure without complacency actually looks like, why boomerang hires keep happening across every region and role, and what it means to be in the middle of a market moment most people won't recognize until it's already passed. Judson's advice: get in front of the rocket and hold on. June's take: being uncomfortable is the new normal, so you might as well get good at it.

Peer Review: CircleCI's CEO & CTO on Why They're Both Building Again

Jim Rose and Rob Zuber have been working together since 2011. By now they can plan a quarter with hand signals. But this episode of Peer Review isn't about how well they know each other. It's about what they're still figuring out. CircleCI's CEO and CTO sit down to talk about what they've always believed about software delivery (it's about outcomes, not craft), how the pace of change has forced them back into the trenches of actually building, and what it means to lead a technical organization when the state of the art is shifting faster than any pitch deck can keep up with.

Junior developers have one big advantage right now

Everyone keeps saying we don't need junior engineers anymore. This episode makes the case that's exactly wrong. Rob sits down with two CircleCI colleagues at opposite ends of the experience spectrum: Hanabel Mengistu, a new grad less than a year into her first engineering role, and Michael Webster, who has been writing software professionally since 2012. Together they explore what it actually feels like to enter the industry right now, when AI has reshuffled the deck for everyone.

Designing exceptions that developers won't route around

Every dependency security program needs a way to handle packages that have a valid business reason to stay in use despite a CVE or license issue. Ideal exception processes give developers full context upfront, including safer alternatives, then route real requests to a security team that weighs the risk profile and logs who requested it, who approved it, and for how long. Get the friction wrong in either direction and the process fails: too much and developers route around it, too little and it becomes the default path.

Publicly available doesn't mean safe to pull right now

Open source is the backbone of most software. But should developers trust OSS? npm, PyPI, and Maven don't vet packages before publication, so "publicly available" doesn't automatically mean "safe to pull right now." A secure OSS posture is to trust the ecosystem but verify at ingestion: route packages and dependencies through a controlled layer that runs scanning, age checks, and malware detection before anything reaches a build.

The Secret Sauce of SLSA: DevGovOps at the Speed of Agentic AI

Software supply chain engineering has reached a critical inflection point. As autonomous AI coding agents transition from generating autocomplete suggestions to planning, writing, reviewing, and deploying entire software pipelines without humans in the loop, the connection between human intent and production binaries is fracturing.

DevOps and CI/CD Practices for Scaling Mobile App Backends in Fintech

Fintech mobile applications operate in an environment where performance, reliability, and security are equally important. A slow payment request, an API outage, or a failed deployment can affect thousands of transactions and quickly undermine customer trust. As a product grows, its backend must handle rising traffic without sacrificing stability.