What this rung really is
Level 6 is where you stop being the one who checks the work. You write the spec first — a plain description of what 'done' actually means for this job — and the agent builds to it. The spec is the standard the work has to hit, decided up front, not argued about after.
Then the real shift: before it hands anything back, the agent grades its own output against that spec, catches what's off, fixes it, and checks again. What reaches you is already right — not a draft you have to inspect line by line. The system holds itself to the standard, so you review outcomes instead of hunting for mistakes.
Write the spec — let the work check itself
The move at this rung is spec-driven, self-checking work: state what 'done' means up front, have the agent build to it, then grade its own output against the spec before it ever reaches you.
This rung sits on everything you wired in rungs 1–5. You add a spec & self-checking on top — you don't start over.
Do this rung, for real
Everything you need is here — no tabs to chase. First, the jargon this rung throws at you, in plain words. Then the steps, with the exact things to paste or say.
A client wants 40 product pages rebuilt to a strict standard: every page needs a unique meta title under 60 characters, a 150-word intro in the brand voice, three internal links, and valid schema. Before, you'd spot-check a few and hope the rest matched. At L6 you write that list of musts as the spec, the agent builds all 40 to it, then it runs its own check against the spec — flags the 6 pages with titles too long, rewrites them, re-checks, and only then hands you the batch. You get 40 pages that already pass, plus the report showing they do.
The spec
A short, plain-language list of what 'done' means for a task — the musts the work has to satisfy, written before the work starts. Not code; just the standard, stated clearly enough that pass-or-fail is obvious.
Why it matters here — It turns a vague request into something checkable. Once 'done' is written down, the agent can build to it and prove it hit it — and you stop re-explaining what you wanted halfway through.
Self-checking (agentic QA)
The agent grading its own output against the spec, catching what's off, fixing it, and checking again — before it ever hands the work to you. The maker is also the inspector.
Why it matters here — It moves the quality check from you to the system. You review finished, already-passing work instead of being the error-catcher on every run — which is what lets you trust the agent on volume.
Write the spec before any work starts
Open the agent on the task and, first thing, dictate what 'done' looks like as a short list of musts — the standard the output has to hit. Keep it concrete enough that each item is plainly pass or fail.
“Before you build anything, write a spec for this job: list every must-have — unique meta title under 60 characters, a 150-word intro in our brand voice, three internal links, and valid schema on every page. Save it as spec.md.”
Have it build to the spec, then check itself against it
Tell the agent to do the work and then grade its own output against the spec it wrote — find anything that fails a must, fix it, and re-check until every item passes. The check is part of the run, not your job afterward.
“Build all the pages to spec.md. Then check each page against spec.md, fix anything that fails a must, and re-check until they all pass.”
Review the proof, not the work
Ask for a short pass/fail report against the spec alongside the output. You read the report to confirm it cleared the standard — you're reviewing the outcome, not inspecting every line by hand.
How you know it's working
Before L6: the agent hands you a draft and you become the quality check — spot-checking, finding the misses, sending it back. The bigger the batch, the more it falls on you, so you can't really trust it on volume.
- You wrote down what 'done' means as a spec before the work started — the standard is explicit, not in your head.
- The agent graded its own output against that spec, caught its own misses, and fixed them before handing it over.
- What you received already passed — you reviewed a pass/fail report, not every line of the work.
- You can hand it a 40-item batch and trust the result, because the check rides along with every run.
Make it stick. Pick one recurring task you currently quality-check by hand — a page batch, an audit, a content set. Write its 'done' as a spec once, and make 'build to spec, then check yourself against it' the standard way you run it. The day you review the report instead of the work, you've cleared the rung.
Our skills for this rung
Linked items are founding-circle skills — clone the repo and run ./install.sh from the skills folder. Unlinked items are practices you build by doing.
Spec-driven run with a QA loop. Share the spec + an audited output.
Clear this and you've genuinely cleared the rung — not read about it. Keep the proof; it's how you place yourself on the ladder.