When AI Writes 80% of Your Code, CI Becomes the Bottleneck
For two years, the debate about AI coding has been about a question that no longer matters: will AI replace programmers? On September 14, 2026, Anthropic published material that quietly invalidates the premise. Its engineers now ship, on average, 8x as much code per quarter as they did from 2021 to 2025, and more than 80% of the code merged into the company's codebase is authored by Claude. Writing code is no longer the constraint. Code review is no longer the constraint, either — an automated Claude reviewer now reads every proposed change.
The first thing that actually broke was the CI system. Test cases across Anthropic's codebase grew 10x, and continuous integration (CI) job volume exploded 25x in six months.
The thesis of this piece is simple: the real bottleneck in AI software development has migrated from generating code to verifying and delivering it. When production capacity grows exponentially, every piece of engineering infrastructure designed around a human cadence becomes the battleground.
Why CI Fell First
The details of Anthropic's CI incident are more informative than any productivity claim. The company runs a test impact analysis service — a deterministic system that decides which tests run on each pull request (PR). Two components keep it working: a "listener" records test results from every CI run, and a "selector" reads that history to decide what to run on newly opened PRs. The architecture worked fine in the human era. It rested on one fatal assumption: commits are sparse, and there are off-peak windows to catch up.
AI destroyed that assumption in three ways at once.
First, PRs got smaller. Claude prefers smaller, more granular PRs — one small change per PR — so the frequency of pipeline triggers grew geometrically. Second, the off-peak window vanished. Agents do not sleep. They push code, run tasks, and refactor overnight and on weekends, erasing the nighttime buffer that used to absorb backlogs. Third, tests exploded. Alongside every logic change, Claude writes dense unit and integration tests; the codebase's test suite grew 10x.
The compounding result: when the single-process listener lagged just 20 minutes, tens of thousands of test updates never reached the selector. Bad changes got merged, and engineers across the company started investigating failures that had nothing to do with them. Flaky tests began blocking merges. Newly fixed tests sat invisible, regressions spread.
In a world where code is written instantly, verification queues up.
Three Patches, Each Shorter-Lived Than the Last
Engineer Sachin Malhotra's retrospective reads like a case study in patch decay.
Patch 1: a bigger machine. The team doubled the cores running the service. Everyone knew it was temporary; nobody expected it to last only 70 days.
Patch 2: sharding. Instead of one global writer, each package got its own shard worker with its own writer — code that Claude itself generated. That bought 29 days.
Patch 3: daily restarts. By March 2026, the service hit its memory limit by mid-afternoon on most weekdays. The team found only four bugs, swapping the memory allocator did nothing, and nobody dared run memory profiling on a heavily loaded singleton. So they scheduled daily automatic restarts. Under AI's relentless concurrency, the restart trick lasted less than a day; the listener repeatedly fell more than an hour behind, and the selector was choosing tests from stale data.
Seventy days, 29 days, under one day. Patch lifespan collapsed exponentially — that is the real rhythm of the AI era. As Malhotra put it, each classic scaling technique now buys a fraction of the time it did a year ago, while a full redesign takes a fraction of the time it used to.
The final fix was the one Claude had argued for over months: tear down the whole singleton. The team gave the test selection service an in-memory data store. Any listener worker can now process any result, append it to a journal, and move on holding nothing in memory — stateless, and therefore horizontally scalable. A small consumer process rolls the journal up into per-test history every few seconds, and the selector reads it instantly. After cutover, a backlog that had been piling up by hundreds of thousands of events went flat. One engineer built it in three weeks; a year ago it would have taken a quarter. Writing code is no longer expensive. Deciding whether to rewrite is.
A Framework: Verification Bandwidth Is the New Throughput
Abstract the incident into a reusable tool: a delivery system's throughput is set not by its fastest stage but by its verification bandwidth — how fast tests give feedback, how reliably results flow, and how quickly failures get localized.
In the human era, writing code was the slowest stage, so verification bandwidth was always in surplus and nobody treated it as a resource. AI drove generation cost toward zero, and verification bandwidth became the hard constraint: scarce, incompressible, and unlike code, unable to grow exponentially. Anthropic's core mistake was expanding capacity linearly against exponential growth. Malhotra's advice is blunt: assume your architecture will face 25x load within two quarters, and design v0 systems for 10–20x your perceived current scale.
The framework travels. AI customer support that speeds ticket generation 10x will overload the human quality-review queue first. AI-assisted medical imaging saturates the pathologist's confirmation loop first. AI-generated marketing copy overwhelms the brand review process first. The pattern is consistent: whichever stage AI accelerates, the verification stage downstream of it overloads first.
The Bigger Picture: The First Field Site of RSI
This incident is not an isolated war story. Read alongside Anthropic's report "When AI Builds Itself," published the same week, it becomes a single structural signal. That report discloses: on the most open-ended tasks, Claude's success rate rose from roughly 26% to 76% in six months; in April 2026, Claude shipped over 800 fixes that reduced a class of API errors by a factor of one thousand — work the supervising engineer estimated would have taken a human four years; on a fixed-goal experiment optimization task, Claude went from about a 3x speedup in May 2025 to about 52x by April 2026, while a skilled human researcher reaches only 4x in four to eight hours on the same task.
Two more numbers deserve to stand alone. First, a retrospective found that automated Claude review would have caught roughly a third of the bugs behind past claude.ai production incidents — bugs written by some of the best systems engineers in the world. Second, GitHub received roughly one billion commits in all of 2025; by mid-2026 it was seeing 275 million a week, on pace for about 14 billion a year. The entire industry is absorbing AI's capacity shock.
One experiment captures the direction of travel: on a weak-to-strong supervision problem, two human researchers recovered about 23% of a measurable performance gap over a week, while Claude agents recovered 97% over 800 cumulative hours and roughly $18,000 of compute. Humans chose the direction; agents designed every experiment. That is the micro version of the CI incident — humans retreat to deciding whether to rewrite, AI handles how.
Anthropic calls this the precursor stage of recursive self-improvement (RSI) and makes an unusual public appeal: if the trend outpaces safety research and governance, frontier labs in multiple countries will need a coordinated mechanism to slow down. The report is candid that verification is the hard part — training runs are far easier to conceal than missile silos, and arms-control-style regimes took decades to build. We do not have decades.
What To Do About It
If you lead an engineering organization:
- Plan capacity for 25x load within two quarters, and design v0 systems with 10–20x headroom over perceived current scale.
- Keep state out of the process from day one, and refuse to run any critical service as a single instance.
- Instrument everything — give agents the telemetry to hill-climb on their own, and make sure CI jobs flowing in equal jobs flowing out.
If you are an individual engineer:
- Your value is shifting from writing code to defining what is worth writing and judging whether verification results are trustworthy. Take ownership of the direction-setting AI still does badly.
- Audit your team's implicit human-cadence assumptions — off-peak windows, batching, manual queues. Each one is a future listener lag.
If you run platform or infrastructure:
- Verification bandwidth is your core KPI for the next year. Measure today's ceiling, multiply by 25, and that is your demand in six months.
- Horizontally scaled test selection is moving from a heavyweight-company specialty to an industry default.
Code can double overnight. Delivery capacity has to keep up. While everyone competes on how fast their AI writes code, the real separation will be whose systems can absorb it.