Case study · autonomous build · run date 2026-09-02

A 27B model on one Mac built what a 2.8-trillion-parameter model needed four.

Same public challenge prompt. A complete, tested, six-route web product — planned, built, verified, and committed end-to-end by CodeLead orchestrating a small local model, with no human touching the code.

The application, exactly as the pipeline produced it, with its full git history: github.com/CodeLead-ai/silicon-exchange. Reproducibility pack, run log, and FAQ: github.com/CodeLead-ai/silicon-exchange-case-study.

• 3h 39mwall clock, unattended
• 17 / 17increments verified
• 53 / 53model-written tests passing
• 0model errors, 0 failed commands

The challenge

“Silicon Exchange” is a GPU rental marketplace from a public benchmark prompt featured in Alex Ziskind's video “I Gave Local AI and the Cloud the Exact Same Job”: six routes; five business-logic rule sets that must be pure, tested functions (half-open overlap detection, 15-minute round-up pricing with an excess-hours discount, hold expiry, maintenance blocking, combined filter and sort); URL-persisted filters; localStorage reservations; a dark “trading terminal” design language; and a quality bar of npm install · test · build · dev all green.

What the numbers do and don't claim

It is not a speed claim: the cloud agent finished in fifteen minutes. It is a claim that a fixed-cost laptop, with no code leaving it, produced a fully machine-verified result unattended — and that the difference was the governance wrapped around the model, not the model. The local model here is roughly a hundred times smaller than the local reference in the video, and on one Mac it generated faster (about 18 tokens per second versus 14.7) than the 2.8T model did on four.

How CodeLead built it

1. Increment plan

   One planning call decomposed the request into 17 dependency-ordered increments — pure-logic rules (with tests) before the pages that consume them.

2. Coverage gate

   A reviewer checked request-to-plan coverage and injected acceptance criteria for anything the plan missed, before a minute was spent building.

3. Deterministic skeleton

   A runnable, routed, design-system-complete app shell scaffolded with zero model calls — dark tokens, page chrome, component primitives, test harness.

4. Per-increment build

   For each increment: preflight analysis, patch proposal, a safety and compliance check gate, then apply. The model never edits files directly.

5. Machine verification

   A compile gate, the full unit-test gate, a headless-browser acceptance probe on the increment's own route, and a cumulative regression probe over everything built before.

6. Evidence ledger

   Each verified increment is git-checkpointed with its session evidence. Failures revert cleanly and never poison the build; the ledger of what exists — and what failed — grounds every later step.

Honest gates: when a probe or check couldn't verify something, it said so and the increment retried or reverted. Nothing was marked done that wasn't machine-checked.

Why this matters

Frontier-scale results don't require frontier-scale hardware. A governed engineering workflow — planning, scoped execution, machine verification, evidence records — unlocks small local models, which means private, on-premise, fixed-cost AI engineering: no code leaves the building, no per-token cloud bill, no four-machine cluster.

Reference comparison from Alex Ziskind's video, sponsored by Abacus AI; the Kimi K3 and Abacus figures are as stated in the video. CodeLead run: 2026-09-02, qwen3.8-27b (8-bit, MLX) via LM Studio on a single Mac. Build provenance: git log in the receipts repository.