Earlier this year, Faros AI published telemetry from engineering teams that had scaled up AI coding tools. Output had climbed: more epics shipped, more tasks completed. So had something else. Code review time was up 441 percent. Bugs found in review were up 54 percent.
This is the hidden cost of agent-scale output. The model writes faster than any human could. The human still has to read it. And unlike the agent, the human does not get faster when you run more of them in parallel.
Review is where the throughput gain meets the human constraint, and right now most teams are on the wrong side of that trade. They've scaled the generation side. They haven't scaled the review side, mostly because the conventional tools for review weren't designed for this volume or this kind of code.
What breaks down at scale
Reviewing code you wrote yourself, or that a teammate wrote, has natural compression: you have context, you can read fast, you know what to look for. AI-generated code removes those shortcuts. The agent wrote confidently, the diff is large, the structure is plausible, and the mistakes, when they exist, are subtle rather than obviously wrong.
Three things go wrong as volume rises:
- Volume pressure. When an agent can produce a full feature in a session, waiting for a human to review before merging starts to feel like it negates the speedup. Teams respond by rubber-stamping diffs, which turns out to be worse than slowing down.
- Missing specialist attention. A single reviewer, human or agent, looks at a diff generically. Security concerns, naming discipline, dead code accumulation, over-engineering - these benefit from focused, narrow attention, not a single pass that tries to catch everything and misses the specific.
- No feedback loop. When a review catches a problem and loops the work back to implementation, nothing about that failure is recorded. The same class of error shows up again in the next task. The agent that made it doesn't know it made it. Review becomes whack-a-mole.
Patterns teams are using now
None of these are complete solutions, but each addresses a real part of the problem. Most effective setups combine two or three.
Risk-triage before deep review
Not every diff needs the same depth of attention. A config file change and a cross-cutting refactor to core business logic are different review jobs. Teams that apply a quick risk filter first - surface area, blast radius, security-adjacent paths - spend their review time where it costs the most to miss something. The generic "approve or comment" flow treats all diffs equally, which is a poor use of scarce human attention when volume is high.
Specialist passes instead of one generic review
One reviewer trying to catch security issues, refactor opportunities, test gaps, and naming problems all in one pass is likely to give each category thin attention. Separate, focused passes - a security scan looking only at injection paths, exposed secrets, and dependency risks; a refactor pass focused only on dead code, naming problems, and over-engineering - each catch things a generalist pass would route past. The tradeoff is more total review work per diff, so this is most useful on diffs that cleared the risk-triage filter as high-stakes.
Apply small fixes in review rather than loop back
The conventional review model returns a verdict: approve or request changes. When the changes are small and unambiguous - a naming correction, a missing null check, a redundant import - looping back to implementation adds latency without adding much. Reviewers that can apply bounded, low-risk fixes directly reduce cycle time substantially on the long tail of minor issues, while keeping the loop-back for decisions that genuinely need the implementer's judgment. The distinction between what qualifies as inline and what loops back is covered in more depth here.
Record what review catches
If review consistently catches the same class of problem - an agent that over-engineers data models, or habitually skips error handling on async paths - that pattern belongs in context, not just in a diff comment thread. Teams that capture review learnings as agent-visible memory find that the same error classes shrink over time. The pattern stops at the agent level rather than compounding across tasks.
Human sign-off on intent, not the full diff
Reviewing every line of a 400-line diff is not a human activity that scales. What does scale: reviewing intent. Does this implement what was asked, does the approach make sense, are the tradeoffs visible. The mechanical correctness - does it introduce injection paths, does it duplicate logic - can be handled before human review reaches the diff, so the human review focuses on what only a human can usefully do.
The underlying problem: review is where your engineering judgment lives. Tools that speed up generation without also structuring review don't save engineering time overall - they shift it from writing to reading under worse conditions. The goal isn't to review less; it's to review the right things with the right attention.
What a structured review stage looks like
This is the problem defract was built around, so treat this as one perspective rather than the only answer. defract treats review as a named, gated stage in the lifecycle, not an afterthought applied after the work stops. When a task reaches review, a panel of specialist agents runs before the diff reaches you: a security reviewer that covers OWASP-category risks and Tauri-specific concerns, and a refactor reviewer focused on naming, dead code, and over-engineering. The diff is risk-scored: clean reviews reach you as a one-click approve; high-risk diffs surface each concern individually. And review learnings feed back into the memory agents carry into the next task, so the same class of problem doesn't recur by default.
The reviewer can also apply small, unambiguous fixes directly, which removes the loop-back for the long tail of minor corrections while preserving it for real decisions. The structure is designed for the volume that parallel agents produce, which is roughly an order of magnitude more than a solo dev at a keyboard. For the broader picture of what scales and what doesn't in agentic coding, see which agentic coding patterns actually scale.
defract
a gated review stage for your parallel Claude Code agents - specialist reviewers, risk-scored diffs, and learnings that carry forward. free, no caps, no signup.