B.28 — zero model, still 478/478: the intro gauntlet, decomposed into bricks

T.M.B. #28 — the library did the coding. The old 478/478 was our composer harness answering beginner questions. This time no model wrote a line: each problem was decomposed into a tree of typed, pre-verified snippets from the brick bin, snapped together by shape, and run. Same perfect score, but the receipt is different — 20 bricks solved 478 problems. The win isn’t IQ; it’s a library that compounds and a composer ~90× faster than the 14B it’s graded against.

The claim under test

B.27 put the old 478/478 in its place: every family is intro-level (reverse a string, count vowels, factorial, is-prime), so 100% means aces CS101 — the real wins there were honesty (never confidently wrong) and speed (~178× a 14B), not coding skill. Fine. So this page does not re-litigate coding IQ. It asks a different, falsifiable question:

Can the brick bin — a durable, typed, execution-verified library — reproduce that perfect intro score by pure DECOMPOSITION, with zero model in the generation loop, and does the library actually compound (few bricks, many problems)? The claim: yes, 478/478 from the bin alone, and a reuse rate well above 1× — the same bricks serving many families.

The setup

benchmarks/coding_gauntlet_bricks/run.py — the same 24 families, same ~480 probes, same gold as the original scripts/gauntlet.py (execution-graded, gold computed by a Python reference in the file, no model opinion in the verdict). The only change is how werbos answers: each family maps to a brick decomposition over the bin’s vocabulary —

• even numbers → filter(x % 2 === 0)
• sum of evens → sum_list over that filter
• sum of squares → map(x*x) then sum_list
• factorial → product_list over range(1, n+1) (0! = product of [] = 1, for free)
• reverses a string → reverse_text; clamp → clamp; and so on.

Nine clean leaf bricks were grown for the families the imports couldn’t cover — the CryptoBlocks max/min/length bricks are browser workspace-scoped (dead in node) and its fibonacci returns the whole sequence, not the nth number: max_list, min_list, nth_fib, square, double, count_vowels, count_char, is_palindrome, is_prime. Each is execution-gated — it enters the bin only if its own test runs green. Output is captured as canonical JSON so a string result ("olleh") matches gold’s quoted form and a digit-string ("12321") doesn’t read back as a number.

PYTHONPATH=. python benchmarks/coding_gauntlet_bricks/run.py            # the full 478
PYTHONPATH=. python benchmarks/coding_gauntlet_bricks/run.py --compare  # head-to-head vs qwen2.5:14b

Results

478/478 — 100%. 0 abstains. All 24 families green.

The reuse rate is the whole point: 20 bricks solve 478 problems. That’s a library compounding — the same sum_list serves sum-of-array, sum-of-evens, sum-of-squares, factorial-via-product’s sibling; the same filter serves evens, count-evens, sum-of-evens. Every new family that lands mostly reuses what’s already proven instead of starting from a blank page.

Head-to-head vs qwen2.5:14b (same probes, gold owned by neither)

Both perfect — as expected on intro problems. The gap is speed, and it widens with difficulty: the 14B spent 20.6 seconds deriving is-prime from scratch and 14s on nth-fibonacci; the bin snapped pre-verified bricks together and ran them in ~50 ms. qwen re-generates every answer every time; werbos composes what it already proved and just executes. (Steady-state bricks are 50–100 ms; the full 478-probe run averaged 48 ms, so against the 14B’s 7,350 ms the real-world ratio is ~150×.)

What actually moved the number

Two receipts, both about decomposition, not generation:

1. Grow-from-miss is real. Five families abstained at first (square, double, count_vowels, is_palindrome, is_prime — plus the browser-dead max/min) — the honest miss named the next brick to grow. Nine leaf bricks later, all 24 families compose. The gauntlet is a ratchet: a miss becomes a brick, and the brick is permanent.
2. The lambdas earned their keep. even numbers, count evens, sum of evens, and sum of squares all ride filter/map with an inline predicate (x % 2 === 0, x*x) — the higher-order-function bricks closed the last JS-parity gap the week before, and here they carry four families at once.

The honest caveats

• This is the intro tier — read B.27 first. 478/478 here is aces CS101, not can code. On the difficulty-rated ladder (scripts/gauntlet_rated.py, 150→1200) werbos still rates ~350 and falls off a cliff on real algorithms (0/24 on classic DP). Nothing on this page changes that.
• Composition ≠ open-ended generation. The bin solved these by mapping known families to known bricks. It did not invent a novel algorithm. Ask for something with no brick decomposition and it honest-abstains (the moat), it doesn’t bluff.
• A sibling test exposed where generation is still rented. The same week’s memory-bind gauntlet (riff-state a title → build code across turns → run it by name) passed its memory half perfectly but caught the rented coder (deepseek) being nondeterministic on edits — it re-read “shout” semantically and left “charCount” empty. Code generation of new capability is still rented and flaky; brick composition of known capability is deterministic. This page measures the second.
• Network + node exec per probe. Each probe spawns node; the compare makes real ollama calls. The gold is owned by neither model, computed in Python and self-tested.

The verdict

The brick bin reproduced the intro coding gauntlet 478/478 with zero model in the loop, at ~89× the speed of a 14B that ties it, on 20 distinct bricks — a library that compounds. That is exactly the thesis, measured: out-structure, don’t out-generate. It is not a claim that werbos codes hard problems — B.27 stands, the rating is ~350. What’s new is the method: a durable, reusable, execution-verified library did the work a model used to, faster and deterministically, and it gets more capable every time a miss becomes a brick.