When AI Codes Faster Than CI Can Test

Linear's engineering team published a detailed post on how AI coding tools have made continuous integration the new bottleneck. Their test suites almost quadrupled since the start of the year, driven by AI agents generating more code and more tests. Every PR still has to pass through CI, so as development accelerates, CI becomes the constraint that drives up infrastructure costs and leaves developers waiting[1].

The numbers

Despite test suites growing nearly 4x, Linear brought PR wait time down from more than 6 minutes to just over 5 minutes, while cutting runner time per test roughly in half. The improvements came in four areas[1].

Moving off GitHub Actions to third-party runners with faster CPUs and better storage gave an immediate 34% average speed improvement. Some workloads like tsc dropped 52%. Switching to tsgo, the native TypeScript compiler, cut the weekly median tsc check by 73%, enough to move the bottleneck off typechecking entirely[1].

Linting was another target. Custom lint rules depended on TypeScript type information, meaning every lint run had to build the full type graph. Rewriting rules to use static analysis over the abstract syntax tree let ESLint drop TypeScript entirely, reducing API lint time by 68% and full-repository lint time by 55%. Memory usage dropped substantially as well[1].

Optimizing the critical path

Linear's team paid attention to the small jobs that gate everything else. Change-detection jobs were checking out the full working tree even though they needed only a small subset. Capping fetch depth took the slowest gate from 94 seconds to 20. Removing checkout entirely from jobs that never needed a working tree reduced time from 27 seconds to 7[1].

The median change-detection job fell from 26 to 8 seconds. The p90 dropped from 31 to 12 seconds. The slowest run went from 138 to 37 seconds[1].

They also moved cache marker writes off the critical path, shaving 42 seconds from the merge path for every API pull request. After switching runners, checkout times became unstable due to network issues between the third-party runners and GitHub. They replaced actions/checkout with a custom composite action that retries with backoff and aborts stalled connections after 30 seconds instead of hanging[1].

Reducing repeated setup

Setup overhead repeated across every job, like booting a runner and installing packages, meant a job doing seconds of useful work could consume minutes of infrastructure time. Linear preinstalled shared dependencies in a CI base image. Test shards that spent 7 to 8 seconds installing the same Postgres client on every run could start immediately. They also restricted dependency installation to only what each job needed, rather than installing the entire pnpm workspace for every workflow[1].

The harder question

The Hacker News discussion (303 points, 372 comments) raised a question that the Linear article does not address. One commenter wrote: "Everyone's going so fast that they keep hitting walls. Why have we not seen improvements in products? While every post and thread feels like a 90's wall street office, the new Android and iPhone ship with fewer features than usual. Windows takes 3 seconds to show the right click menu. Is everyone just running full speed in circles or something?"[2]

Another commenter offered a measured response: "A good chunk of what my company has been doing with AI falls into either burning down known tech-debt and easy wins that no one ever had the bandwidth to approach, or improving and automating our processes. The former is having a direct and meaningful impact on the quality and availability of our services."[2]

The tension is real. AI coding tools make engineers more productive at writing code, but most of that productivity is going toward infrastructure, tooling, and debt reduction, not new user-facing features. Linear's CI optimization is itself an example: a sophisticated engineering effort that users will never see, but that enables the team to keep shipping without drowning in test wait times[1].

One commenter summarized the situation: "Cost is stable, what users see is the same. Engineers are happier because they can spend more time on that extra round of polish. QA is happier because the stupid bulk operations are handled with AI and they can focus on the hard to find stuff. Same stuff, but with better tooling and most people are happier."[2]

What it means for small teams

Linear's optimizations are applicable beyond their stack. The core lessons are universal: move off slow shared runners, minimize what is on the critical path, preinstall dependencies in CI images, and profile your CI pipeline like you would profile any other performance problem. The fact that a well-resourced engineering team had to do this work at all is the signal. AI coding tools have shifted the bottleneck from writing code to validating it[1].

For small teams and solo developers, the implication is clear. If you are using AI coding agents, your CI costs and wait times will grow. Plan for it. The teams that invest in CI infrastructure now will be the ones that can actually use AI velocity without grinding to a halt[2].

Sources

[1] Linear: "AI coding has made CI a bottleneck, so we reworked ours to keep up" (September 2026)

[2] Hacker News discussion: "AI coding has made CI a bottleneck, so we reworked ours to keep up" (303 points, 372 comments)