AIToday
Large Language ModelsHacker NewsPublished: Aug 22, 2026, 06:00 JST3 min read

Coding agents overwhelmed CI; test selection cut queue times 92%

Coding agents overwhelmed CI; test selection cut queue times 92%

Key takeaway

  • A solo developer using AI coding agents hit a CI bottleneck after generating 500,000 lines of code.

  • By selecting only tests that could be affected by each change, queue time dropped from 7 hours 35 minutes to 35 minutes.

  • The gain came mostly from reduced queueing under load, not faster tests.

3 Key Points

  1. What happened

    A solo engineer using coding agents pushed a hobby project to ~500,000 lines of code and generated changes faster than CI could verify them—a scaling problem the author previously encountered only at large organizations like Shopify. By implementing test selection (running only tests a change could affect rather than the full suite), the author cut p95 total CI time from ~7 hours 35 minutes to 35 minutes.

  2. Why it matters

    The bottleneck was not test execution speed but queueing delay. With a single runner near capacity, modest reductions in work per change produced disproportionately large reductions in queue time—the 92% improvement came mostly from fewer changes waiting, not faster tests. This shows how AI agents' speed of code generation can force infrastructure rethinking even in tiny teams.

  3. What to watch

    The approach relies on useful code boundaries (route files, API files, packages) and a conservative selector that records uncertainty rather than assuming safety. The author still runs the full suite every night and now has capacity headroom; adding runners is deferred until workload genuinely exceeds one machine.

Ask the AI about this article →

Context & Analysis

The author encountered an unexpected scaling dynamic: one engineer with coding agents produced changes fast enough to recreate a CI throughput problem normally seen in large engineering teams. The bottleneck was not inherent to the codebase size but to the *rate* of incoming changes overwhelming a fixed verification capacity.

The root issue was contention. With one runner and multiple changes queued, each taking ~20 minutes, the queue could grow to hours while the runner cycled through work. Traditional scaling—adding runners—addresses throughput but not the underlying problem: every change still triggers the same test suite, so capacity demand grows with change rate. The author's prior experience at Shopify showed that this approach works but becomes expensive.

Test selection inverted the problem. By reducing work per change (from ~20 minutes to a couple of minutes for localized changes), the runner no longer ran near capacity. Queueing vanished, and spare capacity returned. The 92% reduction in p95 total time was almost entirely from eliminating wait, not from faster execution. This works because TypeScript's compiler provides cheap static dependency information, avoiding the runtime-tracing overhead the author had to manage at Shopify.

The approach has prerequisites: the codebase must have clear boundaries (routes, APIs, packages) that the selector can use to map changes to tests. It also requires conservatism—recording uncertainty rather than assuming safety—and nightly full runs to catch boundary-crossing bugs and refresh runtime data. Under those conditions, verification cost scales with change scope rather than change rate.

FAQ

How does test selection work?
The system records which parts of the application each test uses during full runs, and a TypeScript dependency graph shows which parts a changed file can affect. CI intersects those two sets to select only relevant tests. Changes to shared setup, global styles, or dependencies still trigger most or all of the suite.
Why did queueing time drop so much more than test time?
When a single runner is near full capacity, even small reductions in work per change can free enough capacity to eliminate wait times. The 92% reduction in total time came mostly from queueing gains, not from tests running faster.
What happens if the workload grows beyond one machine?
The author plans to add runners only after removing unnecessary work. Otherwise, adding capacity would simply mean running unrelated tests at higher cost.

Get the latest Large Language Models news every morning

AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.

Free · takes 30 seconds · unsubscribe anytime

Ask AI

Ask AI anything about this article. Q&As are published on this page for other readers too.

Related Articles

Next articleNvidia shows AI harness, not model, drives long-horizon task performance

The AI news that matters, in one minute each morning.

Sign up free