Engineering managers spent the past few decades figuring out ways for many programmers to work together on a shared codebase. This work dates all the way back to the “Systems Development Lifecycle” ( RAND, 1975 ) — today commonly referred to as the “Software Development Lifecycle” (SDLC), which defines the following phases: Plan Design Implement Test Deploy Maintain Retire AI has made the step that was previously the slowest and most expensive — implementation — the fastest and cheapest.
That, in turn, has had an impact downstream: overwhelming the people responsible for all the other steps in the SDLC. This ranges from open-source maintainers bombarded with thousands of pull requests and issues, to production engineers trying to save production from falling over as the rate of software delivery increases orders of magnitude. We are all trying to save our systems, our customers, and ourselves from slop.
The answer — paradoxically — is to empower agents to do more. It’s only fair! You’d never let an engineer on your team write code, expect someone else to validate it, merge it, deploy it, hold the pager in production, and triage incoming bugs.
But that’s what most companies are doing right now with agents. Models have improved remarkably, and agents are running over longer time horizons, able to take on much larger tasks. But they are not yet used evenly across the SDLC.
Cloudflare treats agents as our customers. They can buy domains , create temporary accounts and use the entire Cloudflare API . We know that agents need APIs and tools to be able to manage the full SDLC on behalf of our customers — not just the start of it.
And so today we’re introducing the start of a new set of tools that let agents step beyond just generating code and take on more of the SDLC. We’re sharing what we’ve built and learned trying to solve this for ourselves: @cloudflare/ci — a new way to run CI/CD across millions of repos, that can self-heal and spawn agents to do much more complex tasks, build on Cloudflare Workflows.
OpenTelemetry traces in local dev — giving agents the same observability they have in production, built into Wrangler and the Cloudflare Vite plugin. Introducing: Cloudflare Agents and Agent Traces — a new home for observing, maintaining and improving agents, centered around OpenTelemetry traces from agents. How Cloudflare enforces engineering standards using AI — our own experience enforcing best practices across all of our products’ and systems’ repositories and specs.
How we built a software factory to drive Astro’s GitHub issue count to zero — our own experience building systems to automatically triage, reproduce, verify and fix issues for a large and growing open source project. There’s something bigger here though. When we look at the SDLC, even with the best automation, its assumptions do not scale for the volume of code agents can write and the pace at which software teams must move to compete.
We think it’s time to replace the SDLC with the ADLC — the Agent Development Lifecycle. The SDLC is for software teams. The ADLC is for software factories.
Right now, everyone is talking about building “software factories” — agent-driven systems that take input and autonomously build, improve, deploy and manage software. Take an input, whether it’s a production error, a bug report from a customer, or an idea for a new feature, and delegate it entirely to an agent. Even with agents, most software projects are constrained by human-in-the-loop steps.
Humans prompting agents, telling them to keep going, instructing agents to apply feedback from a code review, constantly babysitting many agents and giving them instruction. On most software teams, the human still manages each step in the SDLC model — the only change is that they delegate tasks within each step to an agent. And so the dream behind software factories is: what if you reimagined this approach and built a factory for the entire process of building software?
How can we shift more human time towards the things that truly require human inspiration, taste, and judgement? It would leave us more time to design, to talk to customers, and to dream bigger. A software factory has to manage the same steps in the SDLC, but it demands much more from the platform it is built on.
Because when you hand over the keys and let the agent drive, every manual step that previously relied on a human must be adapted to be: Programmatic — ”ClickOps” was bad practice for humans, but it’s a non-starter for agents. Every last operation needs APIs that agents can call, debug, and rely on. Horizontally scalable — preview deployments were a nice-to-have when humans stared at the screen while building or manually took over a staging server to catch issues before production.
For agents to drive, every agent must have its own preview that matches production. Reproducible — what happens if there’s a bug that you can only reproduce when simulating 4G on an iPhone 15? Or from an IP in a certain country?
Typical unit testing and integration testing tools aren’t going to help here. Real-time, push based — relying on humans to look at the right dashboard has always been a bad way to know if things are working, but it completely breaks down with agents. You need an event that triggers an agent to do work.
Atomic — every change needs to be independently testable, releasable, observable, and reversible without affecting unrelated behavior. Permissioned — you know you probably shouldn’t, but today you give a few trusted engineers the keys to SSH into prod in case things really go haywire. There’s no way you let an agent do that — but without the ability to escalate and get more permissions, how can it do its job?
Self-improving — people learn from experience. The first week ship or the first on-call rotation, humans are slow and need to shadow someone else, but then get better and faster. Agents, too, need ways to learn from experience.
Originally published at blog.cloudflare.com
