Coding agents do not spread evenly. The engineers who already know the system, the failure modes, and what done looks like get a genuine multiplier. Everyone else gets a faster way to produce diffs that still need a judgment call. That is not a training problem you solve with a lunch and learn. It is a capacity problem, and it shows up in the merge queue.
Look at who is sitting on both sides. The senior engineers running agent sessions all day are the same people the organization trusts to approve a change. Product managers are now expected to land pull requests, not just write the spec. The set of people producing code just got wider. The set of people allowed to merge it did not. If agents increase output by an order of magnitude, the review load lands on a handful of humans who are already the most productive generators in the building. You cannot ask them to type faster at review. There are not enough of them. Google’s engineering guidance puts team velocity ahead of individual coding speed and warns that slow reviews delay the whole team’s work.[1]
Generation feeling solved is a warning, not a victory. The queue only stays attached to engineering judgment if no human sees the pull request until it has been beat up by other agents: tests, a security pass, a second run that argues with the first. That is not a polish step once seniors are the scarce resource. It is the only way their attention survives contact with the volume. Human approval still matters. It should arrive after the software has already done the first several rounds of rejection.
Stop treating review as the senior engineer's leftover hours. Put a real environment behind every change, run the adversarial passes there, and let the senior spend attention on the calls that still require taste. The power law does not go away. You either build a review layer that absorbs it, or you watch your best people become the constraint on everyone else's output.
Key takeaways
- Coding agent leverage concentrates in engineers who already know what good looks like.
- Those same seniors own the merge queue while more roles start landing pull requests.
- Adversarial automated review has to run before a human sees the change, or the power law becomes a traffic jam.
FAQ
Why do senior engineers become the bottleneck after coding agent adoption?
The gains concentrate in people who already know the system, and those same people are who the organization trusts to merge. As more roles start landing pull requests, production widens and approval does not.
Does automated review replace human approval?
No. It moves human attention to the calls that still require taste. Tests, security passes, and a second agent arguing with the first should reject weak changes before a senior ever opens them.
Sources
Related Essays
No Human Should See the PR Until It Has Been Beat Up
As agents multiply code volume, reading diffs stops scaling. The answer is adversarial verification, where agents try to break the change before a human ever reviews it.
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.
Generation Is Solved. Merging Is Not
Coding agents made producing pull requests nearly free. Now the backlog lives in review, and the teams that win will engineer the review layer, not just generation.