Coding Agents Made CI the Bottleneck: Anthropic and Linear

Anthropic · Linear · X · ax-trend issue #3557 · Published October 27, 2026

The CI bottleneck in the agent era: Anthropic and Linear playbooks and the shift to a verification layer
Overview: when code production speeds up, verification becomes the bottleneck

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.

Anthropic daily merges: from 2,500 in May to more than 30,000 in September
Anthropic daily merges: up from 2,500 in May to more than 30,000 in September

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.

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.

The order in which agent code reaches CI: code surge, arrival at the top of CI, affected tests, full suite in the merge queue, verification layer
Flow: narrow in normal flow, everything at the merge point

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

AI CodingAnthropicAI InfraAX Trend

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.