A production build, to a fleet - that checks itself

I was building real internal infrastructure, the kind that has to work, and I did not write a line of the code. That sentence still feels strange to type.

The thing being built was production infrastructure for my own system. Not a toy. Something other parts of the system would depend on, that had to be correct. The old version of me would have written every line, because that is the part I am good at and the part I enjoy.

This time I did something different. I made the calls a human should make, and I handed the build itself to a fleet of AIs that check each other. The shape of my involvement changed, and the shape is the whole story.

i.What I actually did

My work was the judgment work. The design forks: when there was a real choice between two architectures, I picked, with reasoning. The name: I decided what the thing was called, because naming is a small act of deciding what a thing is. And the approval: at the end, I judged whether the result was good enough to ship.

That is a real job, and it is the right job for the human. Forks, name, approval. Decisions that require taste, accountability, and a view of what the thing is for. None of those are code. All of them are mine.

What I did not do was write the implementation. That went to two specialized sub-agents with different jobs and a deliberate wall between them.

ii.A builder and a skeptic who cannot be the same agent

One sub-agent builds, test-first. It writes the tests before the code, then the code to pass them, the disciplined way. The other reviews, adversarially, against the spec. Its job is not to be helpful to the builder. Its job is to find where the build does not match what was asked, to be the skeptic.

The wall between them is the part I care most about. The reviewer structurally cannot edit what it reviews. It can find problems and report them. It cannot quietly fix them and move on. That separation matters because a reviewer that can also edit is tempted to smooth over what it finds rather than surface it, and you lose the independent second opinion the moment the same hands that judge the work can also change it. Builder and skeptic have to be different agents, with the skeptic unable to touch the code, or the review is not really a review.

So the work has a natural tension built into it. One agent is invested in the code working. The other is paid, so to speak, to doubt that it does. Neither can become the other. That tension is what makes the output trustworthy without me reading every line.

iii.The one thing my hand stays on

Downstream of all of that, there is exactly one thing I keep my hand on: the irreversible deploy. The fleet builds and reviews and produces something that, by its own internal checks, is ready. But ready and shipped are different, and the gap between them is the one-way door. Putting this infrastructure live is the act that cannot be casually undone, and that act is mine.

Everything before it is reversible. Code can be rewritten, reviews can be re-run, the whole build can be thrown away and redone, because none of it has touched production yet. The deploy is where reversible becomes irreversible, and that is the single point I refuse to delegate. The fleet does the work. I open the last door.

iv.What the human role becomes

This is the part I did not expect to find on the other side of it. Handing the build to a self-checking fleet did not make me less involved in the thing that matters. It moved me to the part that actually needs a human: the judgment, the taste, the accountability for what ships. The typing was never the valuable part. The deciding was.

So the role does not disappear. It concentrates. Architect and approver on my side, builder and skeptic on theirs, and one irreversible gate that stays in my hand. The fleet writes the code and argues with itself about whether the code is right. I make the calls only a person should make, and I open the last door. That is what the human role becomes once you have a fleet that builds and reviews itself, and it is a better job than the one I gave up.

Drafted with Bishop, my AI partner.
Words picked, edited, and approved by me. Model provenance: Claude Code (Claude Opus and Sonnet)