Report #13 · 2026-07-09

The sweep — every backend in the suite goes green

Report #12 cleared workapi by making one test's ask explicit and found a slogan: a "model ceiling" can be an artifact of how we asked. This report turns that lever loose on the rest of the suite. The six Go backends the system had never autonomously greened — logstats, shortener, kvservice, tasks-api, ratelimit, and workapi — are now all green, the 7B completely unchanged. Every wall was one of two things: an under-specified ask made explicit, or a genuinely mechanical scaffolding bug turned into a deterministic gate. Two new gates fell out. Nothing was hand-written green; the model wrote every line of every implementation and test.

Six backends, one unchanged model

Each spec was run through the Builder against the v4 champion, its first residual read, converted, and re-run — the same peel-the-wall loop as every prior report, now aimed at breadth. What the residuals actually were is the interesting part, because almost none of them were a gap in the model's Go knowledge:

Spec	The wall	The lever
`logstats`	miscomputed multi-line aggregation test oracle; broken `Totals()` assertion; `.String()` ≠ RFC3339; a bad line Added instead of skipped	explicit spec: a fully-worked test fixture + control-flow + Format-not-String
`shortener`	`u, err :=` with `u` unused (build); stats checked before the redirect that increments hits	new gate `_fix_unused_var` + make the redirect-before-stats step unmissable
`kvservice`	positional struct literal mis-slotted a status int into a string field; one shared loop PUT every key so "missing" wasn't missing	explicit spec: field-named literals + split the missing-key case into its own focused test
`tasks-api`	dropped the `Update` method from interface AND impl; router called handlers with invented args instead of registering them	explicit spec: implement all methods; pin the handler signature + method-value registration
`ratelimit`	`rec.Header.Get` (method not called); void `Header.Set` inlined as an arg; bucket seeded `last` from real time under a fake clock; zero-time clock; capacity-2 flow that never denied	new gate `_fix_uncalled_method_value` + a request helper + lazy clock seed + non-zero clock + capacity-1
`workapi`	(Report #12) one 13-case integration test exceeded single-function synthesis	split into ten focused per-endpoint tests

Six backends green. One model, never retrained. $0. Together with the four that were already green (jsonapi, usersapi, taskflow, taskapi), the entire held-out suite now builds, vets, and passes its race-tested tests — assembled by the algorithm around a fixed 7B, not by the 7B alone.

What a "model ceiling" was made of

The striking finding, repeated across six independent specs, is a taxonomy. Sort the walls and almost all of them are under-specification, not ignorance:

Dropped a specified step — the redirect before a hits check, the seed before a delete. The spec said it; the model skipped it under a long prompt. Fix: make the required step unmissable.
Couldn't compute the test oracle — the expected values for a multi-line aggregation. The model can write the implementation to match an oracle it's given, but miscomputes the oracle itself. Fix: give the fixture.
Boilerplate it botches differently every time — positional struct literals, a method value used as a field, a void call inlined as an argument. Fix: name the fields, or hand it one small helper to reuse.
State it can't express in one shape — a shared table loop that can't represent "this case has no setup," a mega-test that overflows working memory. Fix: split into focused functions.
A completeness slip — a method dropped from an interface and its impl. Fix: enumerate and insist.

Only a residue is genuinely the model's, and even that split cleanly: the unused-var and uncalled-method-value mistakes are mechanical — the compiler names them exactly — so they became deterministic gates that fix them the same way forever, on every future spec, no model involved.

Two new gates

A gate is Python that reads the compiler's own error and rewrites the exact defect. Two joined the set this sweep, each earned by a wall the fix loop couldn't converge:

_fix_unused_var — u, err := url.ParseRequestURI(raw) where only err is checked → _, err :=. Scoped to blank a captured extra return value only when a real variable remains; a lone unused var is left to the model, since there it usually means a value meant to be used.
_fix_uncalled_method_value — rec.Header.Get(...) where Header is a method → rec.Header().Get(...). The compiler's diagnostic disambiguates it from the valid req.Header field, so only the flagged expression is touched.

Both verified on the real artifacts; the Builder's test suite stands at 168 passing.

The honest shape of the win

This is spec authoring and gates, not a smarter model — and that is the whole point. A good spec is explicit: it states acceptance criteria, the idioms to use, and the one tricky invariant a case turns on. The clarifications we added are what a senior engineer would write for a junior — call Header(), seed before you delete, this bucket starts full under a fake clock. The model still wrote every implementation and every test; we removed the ambiguity a 7B couldn't resolve on its own, and mechanized the failures that were purely mechanical. "The best Go developer" was never going to be a lone model. It is a system — a fixed small model, an agentic loop, a verified retrieval corpus, a growing set of gates, and specs written like a good engineer writes them — and that system now turns real Go backend specs into green, race-tested code for nothing.

Postscript — the whole suite, reliably

After the six, we swept the rest. Two of the previously-"green" specs (usersapi, taskapipro) turned out to be only stochastically green — a shared table loop that couldn't express a per-case setup, a status filter tangled into a generic paginator — the same under-specification classes, made explicit and hardened. The two new gates were checked against the champion specs and regressed nothing. With that, all fourteen specs in the suite converge green and reproduce it — every backend, the toy string kit, the rate limiter, and the one spec we had long filed under "chaotic," now reliably green on the fixed 7B. The best Go developer is a system, and the system builds its whole book of work for $0.

All training, serving, benchmarking and Builder runs are local on an M1 Max with Apple MLX — total cloud spend: $0. The specs, the gates, the verified retrieval corpus, the Builder loop and its green artifacts: github.com/guildlm/builder.