Who Reviews the Robot's Code?

Here's a question I've started asking engineering leaders who are proud of how much code their agents are shipping: who's reviewing it? The answer, more often than they'd like to admit, is a senior engineer who is quietly drowning. We obsessed over making AI write code faster and forgot that writing was never the bottleneck. Reviewing was. And we just pointed a firehose at the slowest part of the pipeline.

This is the part of the coding-agent story that the productivity numbers hide. When an agent generates a 600-line pull request in four minutes, the work didn't disappear — it moved. It moved from the keyboard to the review queue, from the person who understands the change to the person who now has to reconstruct that understanding from the outside, under time pressure, several times a day. If your review process was calibrated for humans who write at human speed, it is now structurally underwater, and no one filed a ticket about it because everyone's looking at the velocity chart.

Why agent-generated code is harder to review, not easier

It would be convenient if AI-generated code were also easier to review. It's usually the opposite, for reasons that are worth being honest about.

The author can't explain it. The single best input to a good review is a human who can say "I did it this way because of X." Agent-generated code arrives without that narrator. The engineer who submitted it may have read it once. The reviewer is now the first person to truly understand the change, which inverts the entire economics of review — the reviewer is doing the comprehension work the author used to do.

It's plausible, which is worse than wrong. Agent code tends to look right. It compiles, it follows the local style, it has tests. That surface correctness lowers the reviewer's guard exactly when it should be raised, because the failure modes are subtle: a misread requirement, an edge case confidently mishandled, a dependency pulled in that didn't need to be, a pattern that's fine in isolation and wrong for this codebase. Obvious garbage gets rejected. Plausible garbage gets merged.

It comes in volume. The whole appeal of agents is throughput, and throughput is precisely what overwhelms a review process built around scarcity. Ten thoughtful PRs a week per engineer was a rhythm. Ten before lunch is a different system, and the reviewer becomes the constraint the whole team backs up behind.

Redesigning review for the agent era

The answer is not "review harder." It's to change the system so that human review is spent where it's worth spending and automation absorbs the rest. A few moves that actually work.

Make the machines clear the runway first. Anything a tool can catch should never reach a human reviewer. Linters, type checkers, security scanners, test suites, dependency and license checks — all of it gates the PR before a person looks. The scarce resource is human judgment, and you waste it the moment a reviewer is the one pointing out a missing null check a tool would have caught for free. For agent-generated code this isn't optional hygiene; it's the load-bearing wall.

Make the agent show its work. A PR should arrive with the requirement it was solving, what changed, what the author verified, and what they're unsure about — and you can require the agent to produce that summary as part of the workflow. A reviewer who starts with context reviews faster and catches more than one staring at a raw diff. The narrator we lost can be partly rebuilt, if you make it part of the definition of done.

Right-size the review to the blast radius. Not all code deserves equal scrutiny. A change to billing, auth, or data deletion warrants a careful human read regardless of who wrote it. A change to internal tooling with strong tests and a tight blast radius might need far less. Routing review effort by risk is how you stop spreading attention uniformly thin across a pile that grew 5x.

Watch the metric that tells the truth. Track review time per PR and review comments per PR on the teams leaning hardest on agents. If review time is climbing and your seniors are the bottleneck, your "productivity" is a transfer of labor to your most expensive and least scalable people. The agentic-coding data is consistent that the engineers who win are the ones fluent in both inline and agentic tools (Anthropic 2026 Agentic Coding Trends Report) — and part of that fluency is knowing how to produce a reviewable change, not just a working one.

Keep accountability with a human. Whoever submits the PR owns it — its correctness, its consequences, its 2 a.m. page. "The agent wrote it" is not a defense and can't be allowed to become a culture. The instant authorship blurs accountability, review quality collapses, because no one feels like the author. The agent is a tool; the engineer is still the engineer.

A tool worth a look: Devin Review

I'll point at one tool here because it's aimed squarely at the bottleneck this whole piece is about, not at writing more code faster. Cognition's Devin Review is built to shorten the comprehension loop on a pull request rather than add to the pile. It groups logically related changes together, orders and explains each hunk so you can read a PR top to bottom instead of bouncing around a raw diff, and flags probable bugs by severity — red for likely bugs, yellow for warnings, gray for FYIs (Cognition). It also pipes the diff into an inline "Ask Devin" session with full-codebase context, so the reviewer can interrogate a change without leaving the review — which is exactly the missing-narrator problem from earlier, partially rebuilt. It works on GitHub and GitLab, and at the time of writing it's free during early release (Devin Docs).

None of that removes the human judgment call — it makes the human faster at reaching it, which is the right place to spend AI on the review side. If you're wrestling with review load on agent-generated code, I'd be happy to show you how it works in a real workflow; reach out if that's useful.

The takeaway

Coding agents didn't remove work, they relocated it — from writing, which was never the hard part, to reviewing, which always was. If you scale generation without scaling review, you've built a faster way to merge code nobody fully understood. Push every mechanical check ahead of the human, make the agent surface its reasoning, route scrutiny by risk, watch review load like a real metric, and keep a human's name on every change. The robots can write all day. Someone still has to be the engineer who says this is good enough to ship — and you have to give that someone a fighting chance.

Sources: Anthropic 2026 Agentic Coding Trends Report