Looks Good to Me

There was a time when LGTM meant something. Someone had opened the diff, scrolled through it, left three comments about naming and one about a missing null check that would have taken down a service on a Sunday. The approval was a signature. If it broke, two people had looked at it.

Code review was the last human checkpoint between a bad idea and production. We complained about it, we waited days for it, we fought holy wars in it over tabs and trailing commas. But someone read the code.

I'll say it plainly, because everyone already knows it: that's over. Not because we got lazy. Because the arithmetic stopped working.

Copy of a Copy

In Multiplicity, Michael Keaton's character is drowning in work, so he clones himself. It goes well enough that the clone makes a clone of its own. That one comes out noticeably dimmer, because a copy of a copy loses detail. Nobody in the house can quite say what went missing. They just notice the results.

Here's how a review goes now. One agent writes the change. Another agent reviews it and opens threads. The first agent fixes the threads. The second one checks the fixes, opens two more, and the loop runs until everything is resolved and the pipeline is green. It looks rigorous. There are comments, replies, resolutions, a tidy history.

Often it's the same model on both sides, with the same training, the same habits and the same blind spots. When they agree, that's not verification. That's two copies of one opinion shaking hands. The bug neither of them can see survives the review, and it survives with an approval attached.

The Flood

The human is still in the picture, in theory. In the best case he checks that the standards were followed and skims the shape of the change. In practice nobody goes into the details anymore.

I don't think that's negligence, and I've stopped pretending otherwise. The volume of code coming out of agents is enormous, and it keeps growing. A senior engineer reading every line of every AI-sized pull request is a bottleneck that turns a week of generated work into a month of review. Teams that insist on it don't get better code. They get a queue, and then they quietly stop insisting.

So specifics are a luxury now. The question isn't how to bring line-by-line review back. It's what has to be true for the system to be safe without it.

What the Reviewer Needs

An AI reviewer can only check the code against what it knows. Give it nothing and it checks the code against itself, which is how you get two clones agreeing.

First, guidelines in every repo. Not a wiki page from three reorganisations ago, but written conventions living next to the code: how errors are handled, how things are named, what's forbidden, what the tests must cover. That turns review from taste into a checklist the reviewer can enforce.

Second, a mapped codebase. The agent should know where things live, what already exists and which module owns what. Otherwise the writer reinvents something that sits two files away, and the reviewer, equally lost, approves the duplicate.

Third, documented contracts, upstream and downstream. Most of the expensive bugs I've seen weren't inside a service. They were at the border, where one service quietly changed a field another one depended on. A reviewer can't catch a broken contract it doesn't know exists.

Without those three, the review loop is two machines confidently agreeing about nothing.

What the Human Owns

Even with all of that in place, you can't hand the whole thing over.

The decision about what to build comes before the code, in an RFC, written down and argued with. That's where a human earns his salary now. Not in the diff, where there are too many lines to care about, but upstream, where there's one idea to get right.

And when the change lands, someone still looks at it from altitude. Does the solution fit the system? Is it the approach the RFC agreed on, or something adjacent the agent found more convenient? Did it touch a boundary it shouldn't have? That review takes minutes, not days, and it's the one the machines can't do for you, because it needs to know what the system is supposed to become.

Review didn't disappear. It moved. From the semicolons to the solution, from the pull request to the plan.

Looks Good to Machines

The clones in Multiplicity aren't evil. They're helpful, eager and cheap, and things only fall apart when everyone assumes someone else checked.

That's the risk with the review loop. Every thread resolved, every check green, a human approval at the end, and nobody actually responsible for whether it was the right thing to build.

LGTM used to mean looks good to me. Today it means looks good to machines. That's fine, as long as a human looked at the plan before the machines looked at the code.