hawkes.aiKey ideas
- The one idea — R1 doesn't say "done" — it proves done. Each acceptance criterion runs down an escalating eight-tier ladder: confirm intent, run it, classify the failure, then repair, fix the env, rewrite the AC, or refactor — and a genuine code bug can never take the T8 soft-pass shortcut.
- How it is shown — One acceptance criterion descending T1 through T8 — passing, or being classified and escalated — with the code_bug path barred from the soft-pass exit.
- The trap to avoid — Thinking "verified" is a single check. It's a descent with a diagnosis step and a hard floor: the soft-pass exists, but it's gated so it can't launder a real bug into a pass.
- What it sets up — So each criterion is proven, not claimed — but what stops the model from just declaring the whole job done and walking away? a mechanical end-turn gate.
Most systems call a task verified after one check. This runtime sends every criterion down an eight-tier ladder — and a genuine bug can never shortcut its way to a pass.
The one idea
R1 doesn't say "done" — it proves done. Each acceptance criterion runs down an escalating eight-tier ladder: confirm intent, run it, classify the failure, then repair, fix the env, rewrite the AC, or refactor — and a genuine code bug can never take the T8 soft-pass shortcut.
R1 doesn't say "done." It proves done, eight levels deep. Take one acceptance criterion. It isn't stamped pass or fail — it's sent down a verification descent, a ladder of eight tiers, each harder than the last. Completion is a depth you traverse, not a box you tick. The descent starts gently. T1 confirms the criterion's intent — what would actually satisfy it, so you test the real thing, not a shallow proxy. T2 runs the criterion for real against the work. If it passes, wonderful. When it fails, R1 doesn't retry blindly — it does something most agents skip. T3 is the step most agents skip: before fixing anything, classify the failure. A code bug — the code is wrong?
How it works — the demo
One acceptance criterion descending T1 through T8 — passing, or being classified and escalated — with the code_bug path barred from the soft-pass exit.
An AC bug — the criterion was mis-specified? An environment problem, outside the code? Three labels, three roads. R1 diagnoses first — the diagnosis routes the repair. Treating a bad test and a real bug alike is how agents fool themselves. Then T4 through T7 escalate, matched to the diagnosis: a code-repair loop for a real bug, an environment fix, an AC rewrite only if T3 proved the criterion wrong, a refactor to make the work verifiable. Rising force, routed by the diagnosis — never a blind flail. T8 is the soft-pass — a guarded exit, granted only when intent is confirmed, the build is clean, and a stub-scan is clean, catching work faked with empty stubs. And here's the hard floor: a code bug can never take the soft-pass. Never. The hatch exists for genuine ambiguity, but it's sealed against real bugs.
The trap to avoid
Thinking "verified" is a single check. It's a descent with a diagnosis step and a hard floor: the soft-pass exists, but it's gated so it can't launder a real bug into a pass.
Why it matters — and what’s next
So each criterion is proven, not claimed — but what stops the model from just declaring the whole job done and walking away? a mechanical end-turn gate.
You can't launder a broken feature into a pass. The trap: thinking "verified" is a single check. It's a descent with a diagnosis step and a hard floor. A soft-pass sounds dangerous — a way to wave work through — but it can't launder a code bug, because classification bars one. That's the difference between a checkbox and a guarantee: the checkbox trusts the agent, the descent traps the failure. So R1 proves each criterion via the T1–T8 descent: confirm intent, run it, classify, escalate, then a guarded soft-pass a code bug can never take. "Verified" is a descent with a diagnosis and a hard floor, not a checkbox. But that guards single criteria. What stops the model declaring the whole job done and walking away? A mechanical end-turn gate. Next.
This is one short episode in AI: Zero → Frontier, a step-by-step climb through how AI actually works. Each episode builds only on the ones before it.
Full transcript 2:45 of narration
R1 doesn't say "done." It proves done, eight levels deep. Take one acceptance criterion. It isn't stamped pass or fail — it's sent down a verification descent, a ladder of eight tiers, each harder than the last. Completion is a depth you traverse, not a box you tick.
The descent starts gently. T1 confirms the criterion's intent — what would actually satisfy it, so you test the real thing, not a shallow proxy. T2 runs the criterion for real against the work. If it passes, wonderful. When it fails, R1 doesn't retry blindly — it does something most agents skip.
T3 is the step most agents skip: before fixing anything, classify the failure. A code bug — the code is wrong? An AC bug — the criterion was mis-specified? An environment problem, outside the code? Three labels, three roads. R1 diagnoses first — the diagnosis routes the repair. Treating a bad test and a real bug alike is how agents fool themselves.
Then T4 through T7 escalate, matched to the diagnosis: a code-repair loop for a real bug, an environment fix, an AC rewrite only if T3 proved the criterion wrong, a refactor to make the work verifiable. Rising force, routed by the diagnosis — never a blind flail.
T8 is the soft-pass — a guarded exit, granted only when intent is confirmed, the build is clean, and a stub-scan is clean, catching work faked with empty stubs. And here's the hard floor: a code bug can never take the soft-pass. Never. The hatch exists for genuine ambiguity, but it's sealed against real bugs. You can't launder a broken feature into a pass.
The trap: thinking "verified" is a single check. It's a descent with a diagnosis step and a hard floor. A soft-pass sounds dangerous — a way to wave work through — but it can't launder a code bug, because classification bars one. That's the difference between a checkbox and a guarantee: the checkbox trusts the agent, the descent traps the failure.
So R1 proves each criterion via the T1–T8 descent: confirm intent, run it, classify, escalate, then a guarded soft-pass a code bug can never take. "Verified" is a descent with a diagnosis and a hard floor, not a checkbox. But that guards single criteria. What stops the model declaring the whole job done and walking away? A mechanical end-turn gate. Next.