How I ship with AI coding agents without breaking production
Agents write most of the code. A fixed release path, checks that grow from every mistake, and one human yes keep production boring.
AI coding agents now write most of the code I ship. That makes a good engineering process faster and a weak one worse. So most of my effort goes into the process, not the prompts: guardrails, reviews and approvals that let agents move fast without anyone losing control.
This is how that process works, step by step.
One road for every change
Every change, big or small, takes the same six steps:
- Spec and “done when”. What to build, and the checks that prove it is finished. Written before any code.
- Agents build. Coding agents implement it on an isolated branch and run the tests.
- Automated checks. Hooks, CI, tests and types catch every failure class I have seen before.
- Second-model review. An independent model reviews the change, read-only.
- Human approval. I sign off. A production release needs a single-use approval tied to that exact commit.
- Release. Deployed, monitored, and recorded with who approved it.
Anything that slips through gets a root-cause fix, and if it slips through again, a new automated check at step 3. That loop is the most important part, so it gets its own section.
Mistakes become checks
The first time something goes wrong, I fix the root cause and write down a lesson the agents can read. A written rule is the weakest kind of protection, though. Agents (and people) miss rules.
So if the same kind of failure happens again, it moves down a ladder until a machine catches it: an editor hook, then a CI check, then a test, and at the strongest, a compile error that makes the mistake impossible to write. When a check takes over, the written rule is deleted, so the rulebook doesn’t grow forever.
Pick a rung to see one failure class walked down the ladder:
First time: an API change ships without updating the client SDK. I fix the root cause and write a lesson so the agents know.
Second time: a hook warns the agent the moment an API file changes without the SDK being regenerated.
CI regenerates the SDK types and fails the build if they drift from the API. The written lesson is deleted.
A test exercises the real API shape the client depends on, so a mismatch fails before review.
Strongest: the client is generated from the API contract, so the mistake cannot even be written.
The result: a bug class can surprise me once, but a repeat ends up caught by a machine, and the safety net lives in the codebase, not in anyone’s memory.
Two reviewers, different minds
Every change is reviewed twice. First by a model from a different vendor than the one that wrote the code, running in a read-only sandbox. Then by me.
Why a different vendor? In my experience, a model reviewing its own output tends to miss what it missed while writing it. A second model, trained differently, catches some of those.
The reviewer’s findings are treated as hypotheses, not orders. Each one gets verified against the code before anything changes. Some are real bugs. Some are wrong. The point is that someone checks.
A person says yes
The rule: agents write and test code, but they don’t approve their own work, merge it or deploy it. Nothing reaches production without a person saying yes, and that yes is tied to the exact commit being shipped. A new commit needs a new approval.
Work that survives a restart
Long tasks outlive a single agent session. A context fills up, a laptop restarts, I go on holiday. So each piece of work carries four things:
- its spec,
- its “done when” checks,
- a live state file with the next action,
- a log of decisions already made.
A fresh session reads those and picks up exactly where the last one stopped. Nobody re-derives a decision that was already made, and nobody pays twice for the same context.
What the research says about speed
It’s tempting to promise a speed multiplier. The independent evidence doesn’t support a fixed one.
In a randomized controlled trial published in July 2025, METR had 16 experienced open-source developers work on 246 real issues from their own large repositories. Each issue was randomly assigned to allow or disallow AI tools. With AI allowed, the developers took 19% longer. They had expected AI to speed them up by 24%, and even after the study they believed it had sped them up by 20%.
METR is careful about what that shows. The authors stress that the result is not evidence that AI fails to speed up many or most developers, and that 16 developers on mature repositories are not representative of most software work. They have since marked those results as out of date.
In February 2026 METR published an update on late-2025 tools. Its estimates now point to a speedup: tasks took an estimated 18% less time for the 10 returning developers and 4% less for the 47 newly recruited ones. Both confidence intervals still include a slowdown. METR calls the data “only very weak evidence” for the size of the change, partly because 30 to 50% of developers said they skipped submitting some tasks they didn’t want to do without AI.
Measured, not asserted
So instead of a multiplier, I measure my own sessions: time to first change, idle time, rework, tokens. A new rule stays only if those numbers improve. Rules that don’t help get removed.
What I won’t claim:
- A multiplier. AI speeds up some work and slows down other work. The studies above show how hard it is to measure even under controlled conditions.
- That judgment is automated. Architecture, security and product trade-offs are decided by a person. Agents do the legwork.
- That it’s invisible. I keep a written record of which models and tools touched which part of the code.
The short version: agents make the typing cheap. The process is what makes it safe.

