The site you are reading was designed, built, reviewed and deployed in a single day. A plan of twelve tasks, sixteen commits, a full visual identity, and production traffic by dinner. Most of the work was done by AI agents.
That sentence is cheap in 2026. Everyone has a demo. The part that is not cheap is this: I would put my name under every line that shipped, and I read almost none of them.
The interesting part is not the speed. It is what it took to trust the output.
01 / The rule
A model earns trust through its harness, not its weights.
You do not buy quality by switching to a bigger model or writing a better prompt. You buy it with the shape of the loop around the model. The loop has three parts, and all three are load-bearing:
- A small, typed action space. The model gets decisions from a closed set, not open-ended judgment. One task, one brief, exact values to use.
- A verifier the model does not control. Its output is worth nothing until something it cannot argue with says otherwise: a test, a build, a reviewer that never saw its excuses.
- On failure, retry with the verifier's error in hand. Not from scratch, not with a pep talk. With the exact error, pasted into context.
Decomposing one hard question into three checkable ones beats asking it once, well, every time.
02 / The shape of the loop
Building this site, the loop looked like this. A plan split the work into twelve tasks, each small enough that a cheap model could execute it by transcription. Every task got a fresh implementer with no memory of the others: just its brief, the interfaces it touches, and the global rules.
Then the part most people skip. Every task also got a reviewer. The reviewer's instructions include one line that does most of the work:
Treat the implementer's report as unverified claims about the code.
The report says the tests pass. Fine. Show me the diff. The report says the file matches the spec byte for byte. The reviewer diffs it again, itself. Findings go back to the implementer with the evidence attached, fix rounds are capped, and a controller rules on every conflict between what the plan says and what the code needs, writing each ruling down. Nothing gets adjudicated silently.
It sounds bureaucratic. It runs in minutes, in parallel, and it is the entire reason the output is trustworthy.
03 / What the harness caught
Theory is nice. Here is what the loop actually caught in one day, none of which I would have caught reading the code myself.
A design that failed people I will never meet. The accent red of this site, on its paper background, measures 3.85:1 contrast. Looks great. Fails accessibility standards for small text. A reviewer computed the ratio, flagged it, and the fix introduced a darker red used only where text is small. You are looking at it in the tags of the catalog.
A lying instrument. The verification pass took mobile screenshots with headless Chrome and reported the layout broken at 375px. It was not. Below roughly 500px, that Chrome build silently lays out the page at 500 and crops the image to the width you asked for. The screenshots were fiction. The agent that caught it did not argue about it: it built a calibration test, a row of fixed-width blocks that wrap at a known point, and pinned the real viewport at 500px. Then it drove the browser through the DevTools protocol instead, found one real overflow at 320px, and fixed that. Verify the instrument before trusting its verdict.
Its own boss being wrong. At one point I ruled, with confidence, that a dependency had to be downgraded to match what was installed. The implementer checked instead of complying: lockfile, dry-run install, build, tests. All green on the newer version. My premise came from stale data. The ruling was rescinded and the code shipped on the version I had banned. A harness where the worker cannot be right against the boss is just bureaucracy with extra steps.
04 / What does not work
The failure modes are all versions of the same mistake: letting plausibility stand in for verification.
Skipping review because the output looks right. Letting the model grade its own work, which is the same thing wearing a costume. Asking one big model one big question and hoping, instead of decomposing into small answers you can check. Trusting the report instead of the diff. Trusting the screenshot instead of the instrument that took it.
None of these fail loudly. That is what makes them expensive. A loud failure costs you minutes. A plausible wrong answer costs you every decision built on top of it.
05 / The point
The fleet did not build this site because the models got smart enough. The models have been smart enough for a while. It built the site because every unit of work passed through a gate it could not talk its way past.
The harness is the product. The model is just the part you rent.