Agents write the PRs now. Who reviews?

TL;DR

Agents produce diffs faster than seniors can audit them. The loop stays sane with: draft PRs only, review the seams and sample the rest, and tests as the review multiplier. The scoreboard: review load per shipped change. Up means you built a machine that converts senior attention into merge commits.

Code generation got cheap. Review didn't. That asymmetry is the whole problem with autonomous agents in real codebases.

An agent can produce a working feature in an afternoon. The review load lands on the same senior engineers as before. Except now the diff volume tripled, and the author can't defend the code in review. The author is a loop.

I've shipped agent-built features through real review. The rules that kept it sane:

Draft PRs only

An agent's output is a proposal, never a contribution.

Draft PRs force the right posture: a human opens the finished work, not a supervisor babysitting a half-built one. The agent doesn't push to main, doesn't merge, doesn't self-approve.

The merge button is a human ritual for a reason.

The review inversion

The sharp edge: when code was expensive to write, seniors could review faster than juniors could produce. AI flips it. A junior with an agent now generates code faster than a senior can critically audit it. The rate-limiting factor that kept review meaningful is gone.

What used to be a quality gate is now a throughput problem. And throughput problems don't get solved by trying harder at the old gate.

Review the seams, sample the rest

Line-by-line review of agent code is a treadmill. What actually predicts breakage:

• Boundaries. Types at the edges, error paths, what happens when the third-party API returns garbage. Agents are optimistic; seams are where optimism fails.
• State. The stale-identity class of bugs, where component state outlives the thing it renders. Agents reproduce the patterns they've seen. Including the broken ones.
• One deep pass beats three skims. If review budget is fixed, spend it on the diff's load-bearing parts and trust the tests for the rest.

FROM PROD

The agent failure I see most: code that handles the happy path with the confidence of a senior and the error handling of an intern. Optimistic parsing, silent catches, assumptions about API responses that were true in the training data.

Tests are the review multiplier

The loop I trust: agent writes feature + tests, CI runs the suite, humans review the seams and the test quality.

A test that asserts the buggy behavior is worse than no test. Test review is where the judgment goes: "does this test fail if the world changes?" is a senior-engineer question. That's where the time belongs.

The scoreboard question

Same standard as any AI initiative: did review load per shipped change go down or up?

If agents tripled your diff volume and your review hours, you've built a machine for converting senior attention into merge commits. If cycle time dropped while change failure rate held steady, the loop works.

The agents are getting better every quarter. The review discipline they demand is not new. Good teams always had it. Cheap code just made skipping it impossible to hide.