For fifty years, code review has been a near-sacred ritual in software engineering. Since Michael Fagan formalized "code inspection" at IBM in 1976, the workflow has stayed remarkably stable: one engineer writes code, another reads it carefully before it gets merged. The reviewer hunts for bugs, suggests cleaner approaches, asks "did you think about X?", and approves the change. This practice is so embedded that virtually every serious software organization on Earth — from two-person startups to Google — treats it as non-negotiable.

Monperrus argues, provocatively, that this era is ending. His claim: coding agents have crossed a capability threshold where they can do code review better than humans, and the industry should stop pretending otherwise.

The argument hinges on a few observations:

• Agents are tireless and consistent. Human reviewers get fatigued, skim large diffs, and miss issues in unfamiliar parts of the codebase. An LLM-based agent reviews the 800th line of a diff with the same attention as the first.
• Agents can actually run things. A human reviewer typically reads code statically. An agent can execute tests, reproduce bugs, check whether the change actually compiles in edge cases, and run static analyzers — all in seconds.
• Agents have broader context. A reviewer who hasn't touched a module in months has to page it back in. An agent can re-read the entire relevant subsystem on every review.
• The bottleneck has flipped. When agents write most of the code, having humans review every agent-generated PR becomes the slow step — and humans are now the less-capable reviewers in many domains.

Monperrus isn't claiming humans become irrelevant. The shift he describes is more like what happened to compilers: humans no longer hand-check assembly output because the compiler is trusted to do it correctly. Code review, in his framing, becomes an automated quality gate that humans supervise at a meta-level rather than performing line-by-line.

The key insight is uncomfortable: code review's value was never the ritual itself — it was catching defects and maintaining quality. If agents catch more defects faster and cheaper, then defending human review on principle is mistaking the tool for the goal. The same logic that retired punch cards, manual memory management, and hand-rolled assembly is now coming for the pull request comment thread.

Whether or not you buy the strong version of the claim, the paper forces a question every engineering org will face in the next year: what is human code review actually for, once agents can do it competently?