Grill before you capture
/task:grill is the optional pre-capture step. It sits at the very first stage of the pipeline — "discuss freely in chat" — and gives that discussion teeth. It interrogates a plan or decision one question at a time, keeps a running ledger of what you decided and why, ends with a pre-mortem, then routes you to the right capture skill.
It writes nothing. Its whole output is a hardened discussion plus a decision ledger that a to-* skill then serializes.
Why grill before you capture
A capture skill freezes a discussion into a file. If the discussion was fuzzy, the file is fuzzy. grill is where you pressure-test the thinking before it's frozen — so to-plan / to-spec / to-architecture / to-task / to-roadmap serialize something that's already been examined.
Where it comes from
grill descends from Matt Pocock's grill-me — the interrogate-before-you-build idea that made the case interrogation belongs before code. This one adds a decision ledger, recommendations that are allowed to disagree with you rather than rubber-stamp, a closing pre-mortem, and routing into capture — the part grill-me leaves open: somewhere to put the answers.
How it works
/task:grill the retry design- It frames the target — states, in a sentence or two, the decision it's about to attack.
- It resolves facts itself. Anything the codebase can answer — what a file does, whether a library is already a dependency — it looks up with plain tools. It spends questions only on genuine decisions.
- It grills, one question at a time. Each question is a real fork with 2–4 concrete options and a recommendation. The first chip is its honest recommended answer — and if your leaning looks like the weaker call, the recommendation will say so rather than agree by reflex.
- It keeps a ledger. After each answer it echoes one new line:
{the decision} — because {the reason}. - It ends with a pre-mortem — one kill-shot question, like "this shipped and failed; what was the cause?" — and folds the answer into the ledger. If the grill was thin enough that no answer here would change the ledger, it skips the pre-mortem instead of manufacturing it.
- It prints the full ledger and routes you onward.
The question count is an outcome, not a target: it keeps asking while an unanswered fork would change what gets captured, and stops the moment none would — a thin decision may settle in 2 questions, a spec-bound initiative may take 12. It asks the biggest-impact forks first, and when only secondary forks remain it asks you whether to wrap up or keep going instead of deciding for you.
No config needed
grill is the one skill that neither reads nor writes anything under .task/ — .task/CLAUDE.md included, so the platform never auto-loads it there. It runs in a fresh, unconfigured project, before any capture exists. Its dialog mirrors the language of your chat.
Where it routes you
When the interrogation is done, grill diagnoses what you actually grilled and points at exactly one next skill:
The tests run in this order, and the first match wins:
| What the ledger turned out to be | Routes to |
|---|---|
| Load-bearing "we chose X over Y because…" technical reasoning — each line names a concrete artifact and the alternative it beat | /task:to-spec |
| A multi-task initiative whose technical shape is also settled — which components it builds, what one item hands another, with no rejected alternative to preserve | /task:to-architecture |
| An initiative that sprawled into several tasks | /task:to-roadmap |
| One task, approach settled | /task:to-plan |
| One task, approach still open | /task:to-task |
The spec test is narrow on purpose: reasoning alone isn't the signal, since every ledger line reads "{decision} — because {reason}" by construction. What separates it from architecture is whether that reasoning binds work the ledger itself doesn't contain — a component layout or "item 2 hands item 4 an event" with no rejected alternative is technical shape, not an anchor, and falls through to the architecture test instead.
It doesn't run the capture skill for you — the footer is the handoff. You review the ledger, then run the suggested command.
→ Next: Roadmaps — capturing a multi-task initiative.