The most useful shift I have seen in agent-heavy engineering teams is this: they care less about whether the code reads well and more about whether the change can be proven to work. Review is moving from inspection to verification.
The pressure is obvious once agents are writing most of the code. Volume goes up. Engineers start contributing outside their home areas, which means reviewers inherit code from people who do not know their conventions. PRs sit. Code review becomes the bottleneck, and reading diffs harder does not fix it, because diff-reading is exactly the activity that stops scaling.
The fix is adversarial verification. Before a human ever sees the PR, an agent brainstorms the ways the change could fail: edge cases, broken adjacent flows, the paths a real user would actually hit. Then it spins up a sub-agent per hypothesis and tries to break the thing. Most attempts come back clean. The ones that do not are exactly what a good senior reviewer would have caught, found before anyone spent human attention on it.
What lands in front of the reviewer then is not a wall of files. It is evidence. Test runs against a real environment. A screenshot of the changed page. A recording of the full user flow working end to end. If the flow works and the change used the design system correctly, an experienced reviewer can approve without reading every line, because review is a primitive, not a ritual of scrolling through renames. Approving verified behavior is a legitimate review. Approving an unverified diff you skimmed is not.
Yes, this costs tokens. Running twenty adversarial sessions against one change might cost triple what the change itself cost to generate. Spend it anyway. The alternative is a senior engineer's hour or a production incident, and both cost more.
The forward-looking version of this is simple: verification becomes a non-optional stage of the pipeline. No human sees the PR until agents have tried to break it and failed. Human attention becomes the last gate, not the first filter. Teams that build this now will merge faster and sleep better than teams still asking people to out-read the machines.
Key takeaways
- Code review is collapsing under agent-generated volume, and reading diffs harder is not the fix.
- Before a human sees a PR, agents should brainstorm failure modes and actively try to break the change.
- The artifact a reviewer approves shifts from a diff to evidence, including test runs, screenshots, and recordings of the working flow.
FAQ
Does adversarial verification replace human review entirely?
No. A human still approves the change. What changes is the input to that approval. Instead of reading every line, the reviewer evaluates evidence that the change works and survived deliberate attempts to break it.
Isn't running dozens of adversarial agent sessions expensive?
It can cost two or three times the tokens of the original change, and it is still cheap compared to a senior engineer's review time or a production incident. Verification is the highest-leverage place to spend compute.
Related Essays
Code Review Becomes the Bottleneck
When an agent ships a working PR every six minutes, you accumulate reviewable code faster than humans can process. The next wall is review, not generation.
Review Is Not a Screen. It Is a Primitive
Build review as a UI screen and you have a feature. Build it as a primitive that takes an artifact type and returns a verification surface and you have leverage.
Merging Code Nobody Understands Is the Real Risk
Autonomous merge sounds like speed until nobody in the org knows what the product is anymore. Human review is how a company keeps a mental model of its own software.
Drowning in pull requests that need your review? Try Tembo Review, a beautiful AI-assisted PR review tool unlike anything you’ve used.