When the task matches no playbook, design one. The deliverable before any code is the workflow itself: a sequence of phases that scales rigor to the task, runs the scientific method, and leaves a decision trail a human can audit after stepping away.
- Ground the goal in repository evidence and invoke /principles for this phase. Invoke /how or /why where needed. State the definition of done as a falsifiable predicate (/principle-prove-it-works); scope, quantified as rough units and effort plus the blockers grounding surfaced; constraints, baseline, and available verification; and the rigor level, biased high. One-way doors and high blast radius get more; reversible low-stakes steps get less. Rigor is gates and artifacts, not "try harder". Present the framing and tradeoffs before committing to a long run; reversible work proceeds, but a multi-hour run earns one checkpoint. Complete when the task can be judged by an artifact or observation rather than activity.
- Design the smallest sufficient execution playbook. Decompose into atomic, independently-landable units, sequenced riskiest-unknown-first, with scaffold and verification before features (/principle-foundational-thinking). Build the verification harness before the work, with the baseline captured from the pre-change state, so the check reads as "old value vs new value". Use /architect or /arena for one-way-door design decisions; skip them for mechanical work whose shape is already concrete; a second arena over a settled design is over-engineering (/principle-laziness-protocol). Parallelize only across seams, giving each worker its own worktree or branch, and don't over-fan. Write down the phases, units, hypotheses, acceptance gates, rollback or rejection conditions, and reporting; that list is what the human reviews. Complete when every phase ends with checkable evidence and the run fits its grant and budget.
- Run the loop, using /swarm for independent work and critics. Each unit is an experiment: state the hypothesis, make the smallest change, measure against the predicate on the real artifact, keep it if it advanced, revert it if it didn't. Verify each unit before starting the next (/principle-sequence-verifiable-units). Verify by inspecting the artifact, never a self-report; when something passes too easily, suspect the observation method before the system. Pair delegated work with a judge. If a worker games the gate, reset and harden the contract; if the gate itself is wrong, fix the gate in its own change rather than routing around it. A verdict is VERIFIED, NOT VERIFIED, or INCONCLUSIVE; inconclusive is not a pass. Complete each unit only when its actual behavior is proved.
- Keep the decision trail through /show-me-your-work, a row as each step lands rather than the whole trail at the end. This work is usually ambitious enough to commit the trail so the reviewer can read it in the PR. Replan from evidence, preserving scope and approved-interface gates. A productive run still respects its agreed time limit. Complete each checkpoint when progress, remaining work, and decisions are durable.
- Check the whole against the step 1 predicate on the real product, not just the harness. Encode any recurring correction as a gate, a lint rule, a check, or a script (/principle-encode-lessons-in-structure). Return the playbook you designed, the rigor level and why, the decision-trail path, the predicate result and evidence, alternatives, and exact gaps. Use /ketchup to explain the user-facing result. Complete when the goal is demonstrated or unfinished work has a concrete handoff; effort alone never establishes completion.