By ByteBot
On September 21, Linear published an engineering post that put a name to something most AI-powered teams are quietly experiencing: their continuous integration pipeline became the bottleneck. AI agents now generate approximately 2,000 tests per week at Linear, quadrupling the test suite since January. Without intervention, each PR run was heading toward 11 minutes. Linear rebuilt the pipeline — and their post is effectively a blueprint for what every AI-heavy team will face in the next 12 months.
When Code Velocity Outpaces Validation
The ratio has inverted. Before AI coding tools, the constraint was writing code: teams spent a week building features and a day deploying them. After agents, the constraint is verifying code: you can generate a week’s worth of features in an hour, but your CI queue is still sized for humans. Linear’s test suite grew from its January baseline to four times that size, driven almost entirely by agents writing tests automatically. That pace doesn’t slow down as AI tools improve — it accelerates.
Linear’s data makes this concrete. Without the changes they shipped, their current test suite would take roughly 11 minutes per PR run — double what developers would reasonably tolerate. After rebuilding the pipeline, they landed at around 5.5 minutes, with runner time per test cut approximately 50%. That’s the difference between a CI pipeline that’s annoying and one that actively blocks work. However, it also means Linear needs to keep optimizing as the test count continues to climb.
Four Fixes That Cut AI Coding CI Wait Time in Half
Linear’s approach was surgical rather than wholesale. Instead of migrating to an entirely different CI platform, they attacked four specific constraint layers. The results are concrete enough that other teams can benchmark their own pipelines against them.
Infrastructure first: moving from GitHub Actions to faster third-party runners delivered a 34% average speedup. Switching from tsc to tsgo, TypeScript 7’s Go-native compiler, cut the weekly median TypeScript check time by 73%. Rewriting custom lint rules to use static AST analysis instead of full type-graph builds reduced API lint time by 68%. These aren’t incremental tweaks — they’re order-of-magnitude changes to individual bottlenecks.
Setup overhead was the second target. Linear batched seven previously independent check jobs into two with concurrent task execution, saving roughly 87,000 runner-minutes per month — 11.8% of total CI usage. They moved Postgres client installation into the base CI image, switched from restoring a cached node_modules directory (28 seconds) to a filtered install (7.5 seconds, faster because the lockfile changes constantly), and replaced full database migration replays with schema snapshots — cutting that step from 12 seconds to 1-2 seconds per container.
Test execution itself was the final layer. Increasing Vitest shards from four to eight, enabled only after setup got faster, cut the slowest shard from 5.25 to 4.33 minutes. Module state sharing via Vitest’s isolate: false option for safe files eliminated redundant rebuilds of entity, GraphQL, and decorator graphs — reducing total shard runtime from 32.8 to 22 minutes per run.
Related: Nx 23.2: Oxlint Cuts Monorepo Lint Time 6x, Oxfmt Replaces Prettier
Linear’s CI Problem Is Everyone’s CI Problem
Linear isn’t an outlier. Stripe’s agents now generate approximately 1,300 pull requests per week, up from around 300 before agent adoption. OpenAI runs roughly one million builds per day across 1,500 engineers — about 660 builds per engineer daily. GitHub Actions experienced a roughly 10-hour outage in July that analysts partly attributed to the volume increase from AI-generated workflows. The CI infrastructure assumption — that human developers commit code at human speed — is no longer valid for teams that have meaningfully adopted coding agents.
The practical implication is that CI architecture is now a competitive variable. A team whose validation pipeline adds 10 minutes to every agent-generated PR isn’t just frustrated — they’re losing the compounding productivity gains that justified the AI tool investment in the first place. Faster runners and native compilers aren’t luxuries; for agent-heavy teams, they’re the cost of running the workflow at all.
Related: Worktrunk: The Git CLI Built for Parallel AI Agents
Faster CI Doesn’t Answer the Harder Question
The Hacker News discussion around Linear’s post surfaced a sharper critique. The most-upvoted comment asked bluntly: “Everyone’s going so fast that they keep hitting walls…Why have we not seen improvements in products?” One developer from a company with heavy agent adoption gave an honest accounting: QA was unblocked, operations logs improved, costs going down — but “not offsetting AI spend.” That’s not a failure of CI optimization. That’s a product direction problem.
Linear solved the right technical problem. A 5.5-minute PR cycle for an agent-generated test suite is genuinely good engineering. But the harder question — whether a 4x increase in test volume maps to 4x better software for users — doesn’t have a CI answer. That’s what the Linear post carefully avoids saying, and what the HN debate makes unavoidable. Faster validation is necessary infrastructure. It’s not a product strategy.
Key Takeaways
- AI coding agents are generating tests faster than CI pipelines were built to handle — Linear’s test suite grew 4x in 9 months and will keep growing
- The highest-ROI fixes are infrastructure (faster runners, tsgo), setup reduction (batch jobs, schema snapshots), and test execution (sharding, module state sharing)
- GitHub Actions is showing strain at AI-scale; every agent-heavy team should benchmark their runners and evaluate alternatives
- Fixing CI throughput is a prerequisite — but product velocity and code velocity are not the same thing, and the faster your agents ship, the more that distinction matters
