Build1 distinct publisher3 min readPublished
One passing assertion on a three-line function covers 47% of its lines and catches 2 of 21 injected faults, which is the shape generated tests get accused of, though the harness measuring it needed eight fixes first.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Coverage and kill rate split on that withdraw example for a reason you can read off the control flow. The suite makes one call, `withdraw(100, 30)` [1]. That call satisfies both guards, so neither raise branch ever executes [9]. Change `<=` to `<` in the first guard, as the harness does [8], and no test reaches the edited line. Coverage still reports 47%, because the lines that ran, ran [2][6]. The mutation score reports 9.5%, which is 2 detections out of 21 injected faults and 19 mutants left standing [3][4][5]. On the same file, the coverage figure is roughly five times the detection figure [28].
That 9.5% is a claim about one operator catalogue applied to one small function [4]. Mutation scores move when the operator set moves. For the ratio to carry into your repo, the breakages would have to be of similar kind and the code of similar branch density; a module of straight-line plumbing generates different mutants and a different number. The transferable part is that the two instruments disagree at all, given which one sits in your CI gate.
The author's baseline is where his own premise gets awkward. Before any agent call, the harness ran against 12 maintained Python libraries, among them cachetools, toolz, boltons and tenacity [13]. It generated 455 mutants, and 133 survived the existing suites [14]. Only 53 of those survivors sat on a line the tests actually execute [15], leaving 80, about 60% of survivors, on code the suites never ran at all [16]. He then widened the test command per target, 6 to 40 times more test code, expecting the executes-but-does-not-assert bucket to grow [17]. It went from 54 to 53, and where widening changed anything it converted unreachable mutants straight into kills, skipping the middle category [17][18]. His conclusion is that in mature human-written Python the vacuous test is rare, and suites fail by not running the code [19]. So the high-coverage, low-detection shape he attributes to AI-generated tests [7] is still an assertion here. The measured corpus was human.
Which is why the eight bugs he found in his own harness matter more than the tool, built in about 30 hours for the micro1 Frontier Engineering Challenge and still incomplete [12][26][27]. Editable installs on src-layout packages resolve imports back to the original checkout, so mutations written to a temp copy never executed and three targets scored 0.000 [20]; that would have published cleanly as "the agent fails on src-layout packages," which is a finding, just not a true one [21]. Running mutants in parallel produced three different survivor sets across four runs on the one target doing real async I/O, after a 0.27 to 0.77 result had already been drafted from it [22]. Note the direction of the error: a spurious failure counts as a kill [23]. A classifier scoped to batches rather than tests would have marked all 69 tests in a batch strong on the strength of one [25].
The design I would copy is the gate. A generated test is kept only if it passes on clean code and fails on the mutant, ground truth is a subprocess exit code, and no model judges any outcome [11]. That is falsifiable, and it holds up against a model that writes confident nonsense. The reporting I would copy is the split: an unreachable survivor and an executed survivor are different defects, and one needs a test that imports the module at all while the other needs an assertion [15][18]. A single coverage percentage cannot separate them, and neither can a single mutation percentage.
Ranked by verification strength, evidence, and original report placement.
The example withdraw(balance, amount) raises ValueError when amount <= 0, raises ValueError when amount > balance, and otherwise returns balance - amount; the accompanying test asserts withdraw(100, 30) == 70.
That single-assertion test gives 47% line coverage on the module.
The harness generates 21 small breakages of that module, and the suite notices 2 of them.
Line coverage measures whether a line ran; it does not measure whether anything would have complained if the line were wrong.
One mutation shown in the writeup changes the guard `if amount <= 0:` to `if amount < 0:`.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · September 1, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
An AI test suite hit 94% coverage and missed the one branch that mattered1 distinct publisher
build
Mutation-testing an agent-patch gate scores it at 74% recall on injected defects1 distinct publisher
build
Django's boring core is paying for the churn in everything above it1 distinct publisher
build
Deleting guard lines one at a time found 40 of 61 unmeasured by any test1 distinct publisher
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.
Reproducible at the toy scale, unreplicated above it
The headline pair — 47% coverage, 9.5% kill rate on a three-line function — is something any reader can reproduce before lunch, and the arithmetic checks: 2 caught of 21 mutants is 9.5%. Everything past that lives inside one dev.to post: one author's mutant generator, one sweep of 12 small libraries, no second party who has run it. The unusual feature is that the author is his own most damaging witness, publishing eight defects in the very instrument that produced these figures.
A weekend bench, no users
The only thing this has been pointed at is the author's own target list: 12 pip-installable utility libraries, chosen by him, inside roughly 30 hours of contest work. He calls the tool "sort of" working and incomplete, and this reporting contains no repository, no release, no third-party run, and no CI pipeline anywhere that depends on it.
Sold short, with one unbacked aside
The pull of this piece runs against its own interest. A drafted result of "0.27 to 0.77" is retracted as concurrency noise, the project's founding hypothesis about tests that execute everything and assert nothing is reversed after the data refuses to cooperate, and the tool is downgraded to "sort of" working. Against that, one sentence is doing more work than its evidence allows: the aside that AI-generated tests specialise in high coverage with low detection. No generated suite is measured here, and it is the line readers will repeat.
Contest writeup that names its own bias
A submission tied to a challenge with some 7,800 registrants has an obvious reason to land on an impressive number, and the author states the distortion himself: every bug he happened to find made his result look better, because a disappointing number gets investigated and a pleasing one gets written up. Naming the selection effect is not the same as escaping it — he still chose which checks to run, and by his own account none of the eight were caught by reading code.
Internally consistent, externally unchecked
We are working from a single post by a single author about an instrument he alone has run. The numbers hang together — 2 of 21 is 9.5%, 133 of 455 is roughly 29% survival, 133 minus 53 leaves the 80 unexecuted survivors he describes — and the core mechanism is testable by anyone with pytest and ten minutes. What we cannot do is confirm the library sweep, and the author's own tally of eight measurement bugs is the reason to hold this near the middle rather than higher.