When nobody checks the machine

Someone asked me recently how long I think code review is a meaningful moat. I said a few years, maybe less.

In metal machining, precision cutting machines arrived long before humans stopped checking the parts. Not because the machines weren't trusted, but because they weren't trusted enough yet. The output was rougher than skilled hands could produce, so inspectors checked every piece. That made sense. Then tolerances dropped. Fractions of millimeters, then microns. At some point nobody was manually inspecting parts anymore, not by decision but by obsolescence. The error rate made inspection redundant. The machine was right. Every time.

We're somewhere in the middle of that transition in software.

Engineers review AI-generated code because the tools aren't reliable enough to skip it. Not craft pride, not protecting jobs. Just that inconsistent output quality means a human catching errors is still cheaper than the errors themselves. So we review, and reviewing well is genuinely valuable right now.

But tools improve every few months, not every few years. The gap between "I need to read this carefully" and "I can approve this with a glance" is already closing. A third phase is coming where AI-generated code gets reviewed by AI review tools, and the human in that loop trusts the result. We're not there. But treating the current state as permanent is a short-term bet.

When precision manufacturing made manual inspection redundant, the inspectors who understood quality and failure modes became the people who designed the production floor. Their knowledge moved upstream. Instead of catching problems at the end of the line, they prevented them at the design stage. Same expertise, different leverage point. The machine still had to be right. They just stopped being the ones who verified it was.

I think software follows the same arc.

The person who survives this transition isn't the one who reviews AI code well. It's the one who knows what to build, which tools to connect, how to design a system where errors don't compound into something expensive. Who understands the problem well enough to give AI the right constraints. Who decides what the factory should produce, not just whether what it's producing passes a check.

A flawless pipeline making the wrong thing is worse than a buggy one making the right thing, because it's harder to notice and harder to stop. You can have technically clean output and be building toward nothing useful. The review that catches that isn't a code review.

The shift is from "is this output correct" to "should this output exist." You can automate checking correctness. You cannot automate understanding what needs to exist and why. That requires knowing the real problem, the real constraints, the difference between what was asked and what was meant. It's built from shipping real things and watching them succeed or fail, not from reviewing diffs.

The review window is worth using. Not because review is the endpoint, but because it builds understanding. Catch enough bad code and you develop instincts about what good looks like.

The factory floor designer uses those instincts to design the line, not to walk it.