On August 4, Cloudflare published The Agent Development Lifecycle, their argument that the software development lifecycle needs a rethink now that agents author a growing share of code. The line that carries the whole post is blunt: agents can write code faster than teams can review, deploy, and maintain it. Implementation, for decades the slowest and most expensive phase, is suddenly the fastest and cheapest. The bottleneck did not vanish. It moved into every phase that judges, ships, and keeps the code.
I agree with the diagnosis, and I do not say that from the sidelines. I wrote in AI Writes the Code. Reading It Is the Job. that verification is the skill that becomes senior in this era. Cloudflare’s post is the industrial version of the same argument, extended past review into deployment and maintenance. What I can add is the view from the other end of the scale: I run this lifecycle in production for a team of exactly one, and the shape holds.
The cost did not disappear: it moved downstream#
A performance fix of mine recently shipped in Hasura v2.50.0. The change itself is about 40 lines across two files. Typing it was the cheap part, and an agent could plausibly have typed it too. The expensive part was everything around those lines: finding the slow query in the first place, reading the execution plan until it showed that a null-placement wrapper in generated SQL was defeating every index, proving the engine did not need the wrapper in most cases, and then verifying the fix against the engine’s own test suite. I told that story in The ORDER BY That Hid Our SQL Server Indexes.
That ratio, minutes of implementation wrapped in days of diagnosis and verification, is what the whole industry’s work looks like now. When generation is effectively free, the unit of engineering work stops being the line of code and becomes the judgment call around it: is this the right change, is it safe to ship, and who notices when it goes wrong. A lifecycle that still budgets as if typing were the hard part will drown, politely and one plausible pull request at a time.
A lifecycle for code nobody typed#
Cloudflare’s ADLC keeps the familiar phases (plan, implement, test, deploy, maintain) and re-reads each one under a new assumption: the author is tireless, fast, and unaccountable. None of the phases are new. What is new is that each one must now be designed to absorb authorship at machine speed. Their post is also, to be fair, a product announcement: pipelines as durable workflows, gradual deployments, rollbacks as first-class citizens. The packaging is Cloudflare’s, but the checklist underneath is vendor-neutral, and it is worth reading with your own stack in mind.
| Phase | With human authors | With agents in the loop |
|---|---|---|
| Plan | Scoping was overhead; building was the expensive part | The plan is the deliverable: intent, constraints, and stop conditions in writing |
| Implement | The slowest phase, and the staffing bottleneck | Minutes, effectively free, and always plausible-looking |
| Review | Trust calibrated to a colleague whose blind spots you know | Triage by blast radius; every merged line still gets a human owner |
| Test | Written after the fact, first thing cut under pressure | The main brake: assertions a human wrote on purpose, not generated self-confirmation |
| Deploy | Ceremony around rare, large releases | Gradual rollout and cheap revert, because change volume went up |
| Maintain | Tribal knowledge in heads and hallways | Standards and memory the agent can consume, or every session starts from nothing |
I run this lifecycle at n=1#
Here is why I believe the shape is structural rather than enterprise ceremony: it emerged on its own in the smallest production system I own. This site is a one-person operation where agents do a large share of the operational work. Three MCP servers manage content, publish articles to LinkedIn, and drive a publish pipeline, all through one guarded admin API. Claude sessions write and ship code against written house rules. None of that stayed safe because the models are smart. It stayed safe because of boring lifecycle plumbing.
Every agent client authenticates with a scoped key against rate-limited endpoints, so identity and blast radius are decided at the API, not in the prompt. Publishing an article to LinkedIn goes through a server-side ledger that refuses a slug that was already shared, no matter which client asks, so a retry or a forgetful session cannot double-post. Shared state lives in plain JSON documents that both the agents and I can read, diff, and restore, instead of in anyone’s memory. The standards the agents consume are written in the repository itself, so every session starts from the same rules rather than from whatever survived the last conversation. A small Telegram bot watches the state and reminds me when a step is due, and nothing public happens without a human tick in the pipeline first. The newest piece is an archive that saves each session’s conversation before context compaction, because agents, too, need ways to learn from experience.
The lifecycle is what protects the review budget#
In the reading-AI-code article I argued that review attention is a budget spent against risk. The lifecycle framing adds the other half: the phases around review exist to shrink the surface that needs human attention at all. Written standards make output predictable before it is generated. Tests a human wrote catch the cheap failures without spending anyone’s morning. Gradual deployment makes the cost of a miss smaller, and ledgers make retries safe, which means a reviewer does not have to imagine every replay scenario. What is left over is the short list of diffs where blast radius actually lives, and that list is small enough for humans to read properly.
That ordering is my main advice to teams adopting agents this year: build the pipeline before the prompt library. A better prompt makes one output better. An idempotent API, a rollback path, and a written standard make every output, from every model you will ever use, safer. Prompts are perishable. Plumbing compounds.
- Give every agent client its own scoped credential, never a person’s account, so access can be revoked and audited per agent.
- Make destructive or public actions idempotent on the server, with a ledger and an explicit conflict response, not with prompt discipline.
- Write intent where agents read it: standards in the repository outlive any chat session and apply to every model equally.
- Keep shared state in documents that humans and agents can both read, diff, and restore. State that lives in a conversation dies with it.
- Put a human tick between agent output and anything public or irreversible, and make that gate visible in one dashboard.
- Keep a set of tests a human wrote on purpose. Generated tests mostly verify that the code does what the code does.
- Watch the loop: something must notice when an agent stalls, and something must remind the human what is due.
Typing is now the free part of software. The lifecycle is how you spend the judgment that is not.