QWE AI Academy Here’s the number that should stop you mid-prompt: firms that rolled out AI coding agents saw about 30% more lines of code and 23% more pull requests – yet resolved Jira issues and epics barely moved. The same Harvard working paper (Chen & Stratton, current version dated Aug 4, 2026) also clocked a 49% jump in PR review time. AI coding agents generate more code, but not more software. That gap is the whole game.
If your week already feels like “agent dumps a giant diff → you drown in review comments,” you’re living that finding. Here’s the fix you can run this afternoon: what the data actually shows, why “generate harder” fails, and a four-step gate so more of that code merges.
Why just generating more code fails
Software isn’t one task. Writing is a stage. Review, test, integrate, and release are others. Speed only the first stage and the next one becomes the choke point.
Volume went up. Shipped work didn’t – at least not in a clean statistical sense. In Chen and Stratton’s Jellyfish-based paper (~300M work events, 718 firms, Jan 2021-Mar 2026), agent adoption lifted lines, commits, and PRs hard while firm-level issue/epic completion stayed flat (estimates rule out jumps larger than ~12% of baseline). The win leaked into review: longer submit-to-merge, nearly double the share of PRs sent back for changes, 35% more comments per PR, and a 14% rise in the share of people doing reviews. Employment? Effectively flat – no significant drop tied to agents.
Same shape on GitHub developers. Demirer, Musolff, and Yang (NBER w35275) track successive tool generations: commits and LOC climb a lot; releases climb far less (roughly ~30% cumulative releases vs much larger coding-volume gains). You’re not imagining the backlog.
Think of extra draft code that still needs human scrutiny as inventory on the dock, not trucks leaving the warehouse. Tools that only buy more autocomplete or a bigger agent budget miss that O-ring: downstream attention is the scarce part.
The shipping workflow when agents add code volume without software
Treat the agent like a fast junior who doesn’t get unlimited human attention. Four moves – none of them exotic.
- Spec before code. Write 5-10 acceptance bullets, invariants, and “done when” tests before the agent touches files. You approve a contract, not a surprise architecture.
- Cap the blast radius. Aim for small, reviewable PRs (hundreds of lines changed, not multi-thousand drive-bys). Split features. Stack branches if you must. Huge agent PRs are how that 49% review-time spike shows up on your team.
- Separate author and reviewer. A different model or dedicated review agent does first pass – security, style, missing tests, obvious logic holes. The author agent doesn’t grade its own homework. Humans keep architecture, product risk, and fuzzy calls.
- Gate merge on evidence. Required checks: tests named in the spec, lint/type, AI review summary. No green checks, no human queue.
One short repo instruction file only (CLAUDE.md, copilot-instructions, AGENTS.md – whatever you already use). Rules the agent can’t infer. Long convention dumps raise inference cost and dilute adherence; short stable rules cut the rework the study measured.
Pro tip: Split time-to-first-review and time-in-review for AI-authored PRs vs human ones. If those climb while LOC climbs, you’re stocking inventory. Fix the queue before you buy more generation.
A concrete mini-run
Need: rate-limit the public search endpoint, 60 req/min per API key, 429 with Retry-After.
Bad path: “Add rate limiting.” Agent rewrites middleware, touches auth, adds a package, opens a 40-file PR. Two days in comments. Volume without software.
Better path:
Goal: Rate-limit GET /search to 60/min per API key.
Invariants: existing keys keep working; no global lock; 429 + Retry-After header.
Out of scope: UI, billing, other routes.
Done when: unit tests for under/over limit; integration test hits 429; no new deps without note.
Change only: rate_limit middleware + search route wiring + tests.
Tight diff back. Second agent reviews against the bullets, flags a missing header test. You skim the risk surface and merge. Same feature, fraction of the review load.
Does this feel slower at the keyboard? Sometimes. It feels faster at the merge button – and merge time is what those firm-level charts actually move on.
What still bites teams
The catch is adoption theater. By March 2026, about 95% of studied firms used coding agents and ~80% used some AI code review – yet agents still produced only ~23.3% of review comments and ~10.8% of PRs. Turning on an AI review product does not clear the bottleneck; humans still own judgment work.
Another trap: dashboards that celebrate commits, lines, or token burn. Those go up on purpose after agents. Issue-close rate and customer-visible releases are the scoreboard. Optimize the wrong signal and you scale the choke point.
| Signal | What it usually means |
|---|---|
| LOC/PRs up, issues flat | Review or scope bottleneck |
| Change-request rate rising | Draft quality or PR size problem |
| Reviewer share rising | Org already reallocating – protect time with smaller diffs |
| AI review on, humans still drowning | Review agent not scoped/gated; humans reading noise |
Engineering write-ups on review practice match the papers: shrink the unit of work, put verification before human attention, and stop treating “the agent finished” as “we’re done.”
Honest gap: there’s still no public firm-level benchmark that isolates “small-PR + separate AI first-pass” against unrestricted agent dumps on issue-close rates. Papers report volume and review metrics; a controlled A/B of the full shipping workflow isn’t in them. Measure merge time on your own next three tickets.
FAQ
Do AI coding agents actually increase software shipped?
Not one-for-one. Firm data: big coding-volume gains, little or no clear rise in completed issues/epics. Developer-level work: much smaller release gains than commit gains.
Should I stop using agents until review tools catch up?
No. Use them where verification is cheap and scope is tight – well-specified bugs, isolated modules, tests you already trust. Skip unsupervised multi-thousand-line refactors on critical paths. Pair generation with a separate review pass and merge gates. The tools work; unbounded autonomy on fuzzy tickets doesn’t.
What’s the single highest-use change this week?
Pick your next three agent tasks. Write acceptance bullets and test names first. Force each PR under a few hundred changed lines. Require an AI first-pass summary before any human opens the diff. Compare merge time on those three to your last three unrestricted agent PRs. That bake-off beats another tool trial.
Open your last AI-authored PR that sat more than two days. Rewrite its ticket as a 10-line contract, split leftover work into two smaller branches, and run the four-step gate on the next slice. Ship that slice today.