Build1 distinct publisher3 min readPublished
A team that made a merge queue required for throughput measured 1.76 full runs per landing where a frontier model's batch formula predicted 1.2, because the queue builds every candidate and the last one already holds the rest.
The Engineer · Build desk

build
Three manual interventions in a month, and every guard was working as designed1 distinct publisher
build
Six MariaDB versions, one real difference: the only reason to leave 10.6 is the July 2026 clock1 distinct publisher
build
Force the tool call, then hand Lightsail a long-lived key1 distinct publisher
build
Separating moderation rejections moved one API gateway's success rate from 95.5% to 98.9%1 distinct publisher
Compiled by The EngineerSomething wrong?How this is made
The merge queue's defining feature is what it builds along the way, not just what it merges. Each candidate gets a branch carrying trunk plus every pull request ahead of it in the line, and the suite runs against that branch, once per candidate [9]. Position four is therefore also a test of one, two and three [10]. The redundancy is structural, so the useful question is which of the earlier candidate runs can be stopped while the last one is still green, and what stopping them costs [16].
The common description says otherwise, and says it with a formula. Asked the situation cold, with no queue mentioned in the question, a current frontier model put the merge queue at the top of its list and described one pre-merge run per batch: roughly 1 + 1/B, about 1.2 at a batch of five [8]. Measured behaviour was 1.76 [9]. The formula only fits that number if B is about 1.3, a fraction far smaller than any real batch size [10]. Nobody on the team had used a merge queue before, and the assistant that proposed it also supplied the projection that made the extra runs invisible [7].
Before adopting 1.76 as your own figure, find where your minutes sit. In their gate, 93% of the time is the test step and every linter together is 30 seconds [2], and 40% of the test step is coverage instrumentation rather than tests [3]. Applied to a 13-to-19-minute run, that is 4.8 to 7.1 minutes of instrumentation, ten to fourteen times the whole lint step [2]. Under it sits a floor of about 226 tests that each start a real process and migrate a real database [4]. Their own warning is the one to keep: a reader with 15,000 fast unit tests has a different problem from a reader with 200 that each stand up a database or wait on a browser grid, and what changes between them is what a single avoided run is worth [15].
At 20 to 30 landings a day, 1.76 runs per landing is 35 to 53 full runs [3]. On the machines they already owned, that is 63 to 95 minutes of test time a day; on the small hosted runner it would have been 6.5 to 14 hours [4]. So the hardware move was the larger win in July, ahead of the redundancy fix [11]. The queue's worst day put about 189 builds through, which prices a build near 53 cents against that day's spend [13][6].
Cancelling the earlier runs is free only when the final candidate passes. Kill positions one through three and a failure at position four tells you the combined state is bad without telling you which change broke it [9]. That is the trade the rest of the work has to price. The whole argument rests on one precondition. If your pull requests never wait behind one another to land, none of this reaches you [14].
Ranked by verification strength, evidence, and original report placement.
The project's suite is 15,621 tests and a full run takes 13 to 19 minutes.
Asked the same situation cold (15,000 tests, 17 minutes, running on every pull request and again before landing, 20 to 30 landings a day), a current frontier model recommended the merge queue first, described it as running the pre-merge suite once per batch rather than once per PR, and projected roughly 1 + 1/B full runs, about 1.2 at a batch size of 5.
On 2026-07-20 the test job took 11 to 16 minutes on a small hosted runner while gating every pull request and re-running in the queue; moved onto machines the team already owned and had sitting idle, the same suite finished in 108 seconds.
93% of the CI gate is the test step; every linter the team runs, together, is 30 seconds.
40% of the test step is coverage instrumentation rather than tests.
About 226 tests each start a real process and migrate a real database; the slowest 1% holds 41% of the work, while the other 10,750 tests are worth at most 47 seconds between them.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 29, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Unusually specific, entirely self-reported
The measurements are far more granular than most engineering write-ups — 60 runs against 34 landings, 939 seconds of a 1007-second gate, 22 failures at 13.5 minutes each — and that granularity is the reason to take the piece seriously. It is also the whole evidence base: one author, one repository, no artefact a reader can inspect, and no named tool, so nothing is reproducible. Two internal seams keep the score off the high end: coverage instrumentation is 37% of the gate by one calculation and 93% by another, and the celebrated 108-second run belongs to a suite a third of today's size.
Running in production, in exactly one repository
This is not a proposal. The queue is required, the heavy work sits on owned metal, the pull-request tier runs only affected tests, and there was a real bill for a week — six weeks of dated changes with counts attached. But adoption stops at the team boundary: no other organisation, vendor or user appears, and the author explicitly disqualifies readers whose pull requests never wait behind one another. Deployment depth is high; spread is zero.
Close to honest, with one flourish
Most of the piece argues against its own easy conclusions: deletion is dismissed with the team's own numbers, the precondition for relevance is stated before any figures, and the difference between 15,000 fast unit tests and 200 database tests is spelled out for readers. What tips slightly overstated is the framing of the frontier model as wrong 'in the one place that matters' — one unnamed model, one paraphrased prompt, one answer — and the 108-second run doing headline duty when the suite it timed no longer exists.
Nothing for sale, a reputation in play
No vendor, no queue product, no cloud builder and no model is named anywhere, which is about as clean as a technical post gets — there is nothing to click and nothing to buy. The pressures that remain are the ordinary ones of a developer-platform byline: a headline built on catching a frontier model out travels further than a quiet gate audit would, and the author is grading his own team's decisions six weeks after making them. Anonymising every tool also conveniently removes the one thing a reader could use to contradict him.
Trust the mechanism, hold the numbers loosely
The structural claim is the durable part: a queue that builds every candidate cannot land N pull requests off one run, and the containment that makes the redundancy obvious also explains why cancelling runs costs you attribution. That reasoning stands whatever the telemetry says. The quantities are another matter — single-sourced, self-measured, internally inconsistent on instrumentation cost, and drawn from a repository whose suite tripled inside the reporting window.