Thirteen articles ago I claimed that the software development lifecycle is an inventory-control system for a resource that stopped being scarce, and that we’re not adding AI to the old lifecycle — we’re replacing it with an agentic production system governed by humans.
Time to assemble the thing and see whether it holds together.
This piece is the whole factory: the flow, the places where humans actually control it, the ways it fails while looking healthy, and an honest way to work out where you are. It is meant to be used as a reference. If you read one article from this series and hand it to your leadership team, make it this one.
But first, the sentence the entire series exists to support.
Execution is cheap. Intent, context, verification, judgment, and control are not. A production system that mass-produces the first and ignores the other five is not a fast engineering organization. It is a fast way to ship things nobody understands.
The flow#
Nine stages. Notice how little it looks like idea → requirements → design → code → review → test → deploy → operate, and how much of it is a loop rather than a line.
1. Forming the intent. A human decides what should exist and — just as important — what must not. This is the hardest stage to automate, and it is where quality is really set. Everything after it inherits either the clarity or the vagueness.
2. Packaging the intent. The work becomes an intent package: intent stated as an outcome, context as pointers you can actually follow, constraints in a form a machine can check, verification defined before any code exists. Agents draft it; a human owns the constraints and the refusals. A package that fails the readiness check never enters a lane.
3. Classifying and routing. The system works out the change class from the package and the code it touches. Nobody declares their own class. Blast radius, how easily it can be undone, and how much it matters decide the lane, the autonomy tier, the verification strategy, and which human gates apply. Anything unclear routes up.
4. Execution. Agent lanes do the work, inside written capability grants, with short-lived credentials tied to one lane. This is the pool that stretches on demand. It is also the least interesting stage in the whole factory, which is the entire point of the inversion.
5. Producing the evidence. The change arrives with its case: a reproduction, tests that came from somewhere other than the code, mutation results, property checks, traffic replay where it is worth it, proof it stayed in scope, a blast-radius report, and a plain list of what is still unverified. No evidence means not done — not “awaiting review.”
6. Adjudication. A separate, hostile reviewer attacks the evidence instead of judging the code. Different context, told to disprove the claim, and its verdict binds. Weak cases bounce back before a human ever sees them.
7. Human judgment. For the classes that deserve it: should this change exist, is it shaped right, what happens if the evidence lied, and who answers for it. Ten seconds with a complete case, for most things. Real thought, for the few.
8. Delivery. Verification chosen by risk, state declared, diffs computed, the way back tested before anything runs, policy-as-code failing closed. The pipeline understands the change and picks the strategy. A human approves anything serious going to production.
9. Running it, and learning. Agents observe, explain, recommend, prepare, and — at tiers they have earned — act. Every incident moves a tier, closes a context gap, or turns a decision into a rule. This is the stage that makes the factory get better instead of just keep going.
The nine control surfaces#
A control surface is a place where a human can see, limit, or stop what the factory is doing. Everything else is plumbing. If one of these does not exist in your organization, you don’t have a governance gap. You have an ungoverned system that happens to be behaving.
1. The readiness gate. Controls what enters a lane. Owned by whoever owns the backlog. Enforced by a machine check on the intent package. Missing: agents carry out vague instructions perfectly, and you get confident wrong systems at speed.
2. The constraint set. Controls what may never be built. Owned by senior engineers and architects, versioned next to the code, promoted into enforced rules wherever possible. Missing: every architectural decision gets argued again at review time, which is the most expensive moment there is.
3. The capability grant. Controls what an agent can reach: a fresh identity per run, narrow tools instead of general interfaces, an allowlist for outbound traffic, short-lived credentials tied to one lane, and caps on spend and volume. Owned by a named person per lane. Missing: your blast radius is every credential anyone ever created, added together.
4. The machine floor. Controls what reaches a human at all: lint, types, boundary rules, secret detection, SAST, proof it stayed in scope, required test evidence. Fails closed. Owned by platform. Missing: humans spend their scarce attention checking mechanical rules and never get to the judgment work.
5. The verification requirement, per change class. Controls what counts as proven. Which rung of the proof ladder each class must clear — example tests, properties, mutation thresholds, traffic replay, formal methods. Owned by senior engineers. Missing: “the tests passed” becomes your whole quality story, and that story is about test code, not behavior.
6. The adjudication gate. Controls whether the evidence really supports the claim. Separate, hostile, and binding. Owned by platform, configured by engineering. Missing: decorative tests and sprawling diffs walk through wearing green checks.
7. The judgment gate. Controls what ships, for the classes where it matters. Owned by named humans. Deliberately small, and deliberately real. Missing — or there but rubber-stamped: you have accountability on paper and nowhere else.
8. The autonomy tier. Controls how far each workflow may go alone. It comes from blast radius, how easily you can undo it, and a measured track record. Earned by evidence, taken away by incident, capped forever at prepare-only for anything you cannot undo. Named owner per lane. Missing: your autonomy policy is whatever your vendors set as the default.
9. The halt. Controls whether you can stop. One action, available to whoever is on shift, that stops a lane or the whole fleet without the agent’s cooperation and without a deploy. Tested every month. Missing: every other surface on this list is theory, because you have no way to end a bad situation.
Read that list as an audit. Nine surfaces, each with an owner’s name, each either real or still a wish. Most organizations I have looked at have three or four, and the missing ones are almost always 1, 5, 8, and 9 — readiness, verification requirements, tiers, and the halt. In other words, the ones at the edges, where nobody’s job description reaches.
Five failure modes that look like success#
Each of these produces better-looking metrics as it gets worse. That’s what makes them dangerous.
Velocity theater. Generation capacity scales; verification and judgment don’t. Deploy frequency climbs, PR counts climb, dashboards go green, and merged-to-production time quietly gets worse — the 180% more code shipping 30% more software gap, and the 20%-faster-feeling, 19%-slower-shipping inversion that both LinearB’s telemetry and METR’s trial independently found. How to spot it: put intent-to-verified-behavior time next to deploy frequency. If one is improving and the other isn’t, you know which one is real.
Verification theater. Coverage rises, nobody knows the mutation score, gates let everything through, quarantined tests have no owners, and retry-on-failure stands in for a diagnosis. Your instruments read green whatever the weather, which is worse than having no instruments at all. How to spot it: the mutation score, plus a written list of every continue-on-error in your pipeline.
Approval theater. The judgment gate exists and nothing ever fails it. Override rate near zero, approvals in seconds on 900-line diffs, everyone accountable on paper and nobody actually deciding. Worse than no gate, because it produces a paper trail of decisions that were never made. How to spot it: human override rate per workflow. Near zero means promote the workflow or admit the gate is decoration.
Context rot. Documentation, runbooks, and architecture notes drift out of date while agents read them as fact. Output quality drops with no code change to blame. Humans read docs with suspicion; agents don’t, and that suspicion was an error-correction layer nobody ever put a price on. How to spot it: a named owner on every document an agent can read, and evals that check whether a doc still produces correct behavior.
Comprehension collapse. The system works and nobody understands it. This one is invisible by its very nature. No linter reports it, static analysis calls it fine, and it looks exactly like well-understood code in every system you own. It is also the only failure that takes away your ability to spot the other four, because you cannot judge risk in a subsystem nobody can explain. How to spot it: for each critical subsystem, can two people explain how it works and why it is built that way? Ask in a conversation, not a survey.
The pattern across all five: the failure sits in the constraint nobody measures, and the metric you do measure gets better. That is not bad luck. It is what happens when you mass-produce one stage of a pipeline and keep the old instruments.
The factory maturity model#
Where you actually are. This is about the production system, and it is separate from the Agentic Overwatch maturity model, which is about how the room supervising it is staffed. You can be F3 with a Level 1 room, and that combination will hurt.
F0 — Assisted. Agents make individuals faster inside the old lifecycle. Tickets, PRs, human review of everything, no lanes, no tiers. The process is unchanged; the people are quicker. Most organizations claiming an AI transformation are here, and that is a fine place to be — as long as you know it.
F1 — Lanes without gates. Real agent lanes producing real volume. Verification and review still human and still uniform. This is the most dangerous rung on the ladder. Speed is visibly up, and every failure mode above is quietly piling up. If you are here, the right move is not more lanes.
F2 — Machine floor. Layer 0 is real and trusted: rule checks, secrets, scope, required evidence, failing closed. Change classes are written down. Class A no longer eats human review. Humans still do most of the adjudication, but they have stopped checking rules by hand. This is the first rung where adding capacity is safe.
F3 — Evidence and tiers. Separate, hostile adjudication binds. Verification requirements are written per change class and enforced. Autonomy tiers are set per workflow, earned by a measured track record, taken away by incident. The halt exists and gets tested. Human attention goes almost entirely to intent, architecture, and approving the changes that matter.
F4 — Governed factory. All nine control surfaces exist with named owners. Intent-to-verified-behavior time and cost per verified outcome are steering metrics, published. Every incident updates a tier, closes a context gap, or promotes a decision into a rule. Comprehension is tracked and funded. Autonomy rises deliberately, on evidence, and gets revoked without argument.
Two honest notes. Almost everyone is F0 or F1, and the step between them is one decision someone made without noticing. And F4 is not somewhere you arrive. It is a set of loops that keep running. The value is not the level. It is knowing which rung you are on, because the right next move is completely different at each one.
What never gets automated#
I want to finish on the part that is not machinery, because thirteen articles of frameworks can bury it.
Every control surface in this factory exists to make one thing possible: a human being able to answer for what the system did.
Not “the agent got it wrong.” Not “the model hallucinated.” Not “the pipeline approved it.” A name, a person, who decided this should exist, who bounded what could go wrong, and who stands behind the result when it reaches someone who depends on it.
That is not a nice sentiment. It is the load-bearing part. An organization where nobody owns agent output has no feedback loop, and a system without a feedback loop gets worse until it fails in public. Accountability is what closes the learning loop. Take it away and the factory becomes a very efficient machine for producing consequences nobody can trace.
Which is why “AI replaces engineers” was always the wrong way to see it, and not for comforting reasons. Agents replace execution — the typing, the mechanical work, the pattern-matching, the volume. They cannot carry consequences, so they cannot own outcomes, so someone else must. And that someone needs enough understanding of the system to make the ownership real instead of a name on a form.
That’s the whole inversion, stated as a requirement instead of an observation: as execution capacity rises, the demand for human understanding and accountability rises with it. Not falls. Rises. The organizations reading the inversion as “we need fewer engineers” have it exactly backwards. They need fewer typists and a lot more people able to own systems they did not type.
The craft didn’t leave when the typing got cheap. It moved into the decisions that were always the hard part and never got enough of the week: knowing what should exist, refusing what shouldn’t, proving behavior instead of assuming it, limiting the damage, and standing behind the result.
That was always the engineering. The typing was just how we expressed it.
The agent writes the code. The engineer owns the outcome. Every surface in this factory exists so that the second half of that sentence is operationally true instead of merely inspiring.
Where to start on Monday#
If the whole series comes down to one sequence, this is it. Do them in order — each one makes the next affordable.
- Find your rung. F0 through F4, honestly. Most of the value of this article is in not overstating it.
- Test your halt. Today. If you can’t stop the fleet in thirty seconds from a phone, nothing else on this list is real.
- Cut the destroy permission and put a timer on every credential. Mechanical, fast, and it puts a limit on every mistake you have not made yet.
- Build the machine floor until you trust it — especially secret detection and the scope check. Then stop human review on Class A, with sampled audits.
- Declare verification requirements for your three highest-consequence change classes. Then run mutation testing on them and find out what your suite was actually worth.
- Instrument intent-to-verified-behavior time and publish it weekly. It will start more useful arguments than anything else you can do in a week.
- Write the tier table. Ten workflows, blast radius, reversibility, current tier, target tier, owner. One page.
- Name an owner for every lane and every agent-readable document. A person, not a team. Switch off what nobody will own.
None of that needs a platform purchase, a reorganization, or a better model. All of it is organizational design work, which is exactly why most people will keep waiting for the next release instead.
Fourteen articles in, that’s the thing I’d most want to leave you with. The constraint moved somewhere your budget can’t reach directly. You cannot buy intent quality, context fidelity, verification strength, architectural judgment, or control. You can only build them — and the teams that start now will spend the next two years building on their own work while everyone else is still evaluating tools.
So, the last question of the series, and it’s the same one as the first. Pull up your lifecycle. Find the gate that exists only because writing code used to be expensive.
Then go build the one you actually need.
This closes the series. I lead AI transformation for a global SaaS platform and run autonomous systems in production — agents that investigate bugs, write and review code, validate changes, and handle operational workflows. Everything in these fourteen pieces is a working model, not a finished one, and the parts I’m least sure about are comprehension measurement and where span of control actually lands. If you’ve built any of this, or you think a surface is missing, I genuinely want the argument. Find me on X, LinkedIn, or Telegram.