Coding Agents Made CI the Bottleneck: Anthropic and Linear
The next bottleneck for teams adopting agent coding is not the model but CI. That diagnosis spread into a debate on X: the speed of writing code is already up. The pipeline that verifies the code is falling behind. According to the Anthropic playbook (October 20, 2026), Anthropic's CI load grew 25x in six months. Daily merges jumped from about 2,500 in May to more than 30,000 in September. The Linear playbook's (October 14, 2026) 15 improvements were cited alongside. So was a team case that cut PR wait to about 5 minutes even after quadrupling tests.
The two playbooks point the same way. Run narrowly over the range a change touches in normal flow, and secure trust with the full suite at the merge point. A caution belongs up front: the key figures in this post are secondhand quotes through summary posts, not each company's primary announcement. The primary sources are unconfirmed.
Causes of the CI Bottleneck: Pipelines Designed for Human Output
@mihail_eric's diagnosis, posted on October 26, 2026, runs like this. Anthropic, Linear, and other companies are hitting the same wall in AI software development: CI. For 20 years CI was designed for human output. Now a 5-person team produces a 50-person team's volume of code. All of it arrives at the top of the CI pipeline within seconds. Queues and execution units designed around human work rhythms now have to be redesigned around machine output speeds.
The debate spread on X. The mihail post recorded 24,981 views and 103 bookmarks, while @yonasbe's quote post recorded 16,178 views and 373 bookmarks. The quote post out-bookmarking the original also reads as a signal that the topic landed on working practitioners' save lists.
Load Growth in Numbers: Anthropic CI Load Up 25x in Six Months
Anthropic built its own test selection system to absorb this load. The playbook's advice is blunt: assume you will reach 25x load within two quarters. Comparing the two figures surfaces one more reading. Merges grew about 12x, from 2,500 to 30,000, while load grew 25x. The remainder that merge counts alone cannot explain points to tests and workflows per change getting heavier. In a structure where per-change cost grows alongside volume, adding runners alone cannot keep up: that is what the comparison shows.
A single small default can become a large cost. Under default settings, a stuck job can occupy a runner for 6 hours. At 25x load, leaks like this stop being per-incident losses and become permanent occupation. Adding runners does not catch this class of leak.
The 5-Minute PR Wait Case: Cumulative Effect of Small Fixes
The team case mihail cites goes like this. Even after quadrupling tests, a bundle of a dozen or so small fixes cut PR wait time to about 5 minutes. The fix list: tsgo, oxlint, sparse checkout, preinstalled dependencies, and balanced test shards.
Nothing on the list is a grand replacement. Swapping the type checker and linter, narrowing checkout scope, preinstalling dependencies, and splitting tests evenly added up to the wait time. Each item is small; across the whole pipeline the perceived speed changes. The case is an anonymous anecdote, though, which team it was and whether the conditions are reproducible are unconfirmed. The 5-minute figure is safer as a reference than as a target.
Five Techniques From the Anthropic Playbook
The Anthropic playbook offers five techniques.
- Run only affected tests: narrow execution to the tests a change touches.
- Full suite on main and in the merge queue: run everything at the merge point.
- Skip unaffected workflows: do not run workflows unrelated to the change at all.
- One CI run per change: bundle CI execution for a single change into one run.
- Time caps on flaky jobs: cap stuck jobs so they cannot occupy runners for long.
The core of the list is the separation of selection and guarantee. Day to day, run only the affected range quickly; at the merge point, secure trust with the full suite. It refuses to solve "run fast" and "verify everything" in the same stage. Most items transfer directly to GitHub Actions environments. But the first technique carries a limit examined below: impact analysis itself gets expensive past a certain scale.
Linear Playbook's 15 Improvements: Config Sharing as the Biggest Win
The Linear playbook lists 15 improvements. Moving to faster runners made jobs 34% faster on average and type checking 52% faster. The list includes a native type checker, the oxlint switch, shallow checkout, and moving cache writes off the critical path. It also includes expanding shards from 4 to 8, and sharing configuration across test files. The playbook states that config sharing was the biggest win. The contrast, a structural fix beating a hardware-style runner swap, is a useful reference point when teams set their own priorities.
The overlap between the Linear and Anthropic cases carries meaning as well. Neither company stopped at a runner swap; both touched the whole pipeline: type checking, lint, checkout, cache, shards, and config sharing.
Limits of Smart Test Selection and the Shift to CI as a Verification Layer
mihail also pointed at the limits of smart test selection. Impact analysis that runs only the tests a change touches strains past a certain workload: the selection logic itself becomes heavy. That means the Anthropic playbook's first technique can wobble at scale. So copying the playbook wholesale matters less than gauging which workload band your own pipeline sits in.
This is where the debate lands. Because engineers cannot review all agent-written code, mihail sees CI becoming the verification layer that establishes trust. Review was a human quality gate; CI is taking over that role. Quoting the post on October 27, 2026, @yonasbe added that shortening CI is not only a faster-runner problem. It also needs optimization across workflows and tests. The roundup sits in the same current as Chainguard Checks (October 14) and Blacksmith's unicorn round (October 21). Signals that verification infrastructure is becoming the next investment target of the agent era are converging from several directions.
The figures need source caution. The Anthropic and Linear numbers are secondhand quotes through yonasbe's summary posts, not each company's primary announcement; the primary sources remain unconfirmed. The team case mihail cites is also an anonymous anecdote, with team identity and reproducibility unconfirmed. The playbook links lead to 70+ (Anthropic) and 50+ (Linear) additional optimizations on starsling.dev, and how much of the full lists is public is unconfirmed.
Practical Adoption Order: Apply Now, Hold Until Measured
Practical adoption splits cleanly. Affected-test selection, a full suite in the merge queue, and shard and cache cleanup apply to GitHub Actions right away. Because the figures are secondhand, though, measuring your own pipeline comes before adopting someone else's numbers as targets. This X debate is worth reading as field optimization experience bundled into an opinionated summary. When citing its numbers, the source layering should travel with them.
Sources
- X @yonasbe quote post (October 27, 2026)
- X @mihail_eric diagnosis post (October 26, 2026)
- X @yonasbe Anthropic playbook (October 20, 2026)
- X @yonasbe Linear playbook (October 14, 2026)
- ax-trend issue #3557
FAQ
Why is CI becoming the bottleneck for coding agents?
CI was designed for human output for 20 years, and now a 5-person team produces a 50-person team's volume of code, all of it arriving at the top of the CI pipeline within seconds. According to the Anthropic playbook figures quoted in the debate, Anthropic's CI load grew 25x in six months, and daily merges jumped from about 2,500 in May to more than 30,000 in September. Queues and execution units designed around human work rhythms now have to be redesigned around machine output speeds.
What does the Anthropic playbook recommend?
The playbook offers five techniques: run only the tests a change touches, run the full suite on main and in the merge queue, skip workflows unrelated to the change, bundle CI execution into one run per change, and put time caps on flaky jobs. The core is a separation of selection and guarantee: run narrowly in normal flow, and secure trust with the full suite at the merge point.
What was the biggest win in the Linear playbook?
The playbook states that sharing configuration across test files was the biggest win among its 15 improvements. Moving to faster runners made jobs 34% faster on average and type checking 52% faster. The list also includes expanding shards from 4 to 8 and moving cache writes off the critical path.
How reliable are the figures cited in this debate?
The key figures are secondhand quotes through summary posts, not each company's primary announcement, and the primary sources remain unconfirmed. The team case that cut PR wait to about 5 minutes is an anonymous anecdote, with team identity and reproducibility unconfirmed. The 5-minute figure is safer as a reference than as a target.