Files
command-center/agent/skills/grilling/SKILL.md
T
Frank 3fa0242f56 style(grilling): rewrite in the mattpocock corpus voice (Refs #20)
Read all 36 upstream skills, then rewrote to their house style per
writing-for-agents' own levers: leading words as tokens (frontier,
brief, ledger, artefact, scout), vocabulary-first and used exactly,
positive phrasing with prohibitions kept only as hard guardrails,
completion criteria sharpened to checkable+exhaustive ('counted before
sending', 'frontier empty and nothing sits blocked'), zero history,
gotchas the environment cannot confess kept inline. All settled
behaviour from the grilling-on-grilling session survives intact.
2026-10-18 19:15:14 -07:00

3.4 KiB
Raw Blame History

name, description
name description
grilling Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

Grilling

Interview the user relentlessly until nothing is silently assumed. The subject is a design tree: every decision branches into the decisions that hang off it.

A decision is frontier when it can be asked now, without an answer you haven't heard yet. The interview is done when the frontier is empty: every branch of the tree visited.

Rounds

Work the tree in rounds: ask the whole frontier at once, then wait. A decision whose answer hangs on an open question or an unfetched fact joins a later round.

Ask each closed decision - anything expressible as 2–5 options - through the ask tool:

  • One artefact per question, counted before sending. Name the artefact each question decides; two names means two questions. Shared plumbing (an endpoint, a service, a build step) still leaves two artefacts.
  • Recommended answer first, marked recommended: 0: the user's single Enter accepts it.
  • Options quote the user's goal. Their words, their stated goal, ground the wording; your todo text and table rows stay out of it.
  • Your own idea is welcome: it gets its own recommended question. Attach it to its own question, so it rides there on its merits.
  • multi: true for pick-many, header for the branch chip, preview when the decision needs code or config in front of the user.

Open narrative - "walk me through the deploy flow" - has no options to offer; ask it as prose in chat. Without an ask tool the whole round degrades to text: ❓ **Q1 — title**: body, then ➡️ recommendation, phrased so one bare "yes" accepts every recommendation.

Dialog mechanics, the gotchas no doc confesses: the dialog is exclusive, so dispatch scouts before the ask call in the same message and expect their results between rounds. Esc cancels the whole run with no closing turn; the ledger below is what survives it.

The ledger

The tree lives in the todo list while the interview runs, so the user watches it fall:

  • One task per decision, filed under the phase for its branch; via: <parent decision> in the task text carries the edge.
  • pending is the frontier; block with a one-line reason waits on a fact or an open decision; done is settled. Unblock the moment the dependency settles.

Write local://grilling-state.md at the end of every round: the tree, each decision's verdict and one-line rationale. It is the durable copy of the interview; keep it current so an Esc costs one round.

Facts are yours, decisions are theirs

  • Environment facts (filesystem, repo, live config): dispatch a scout per fact-cluster, batched into one task call, before the round's ask. Cluster tightly; spawns are the expensive route.
  • Outside-world facts: call web_search directly.
  • Cheap lookups: read/grep inline.
  • The main session is where questions happen: every spawn carries the exact facts to return, and comes back into the next round.

Done

The frontier is empty and nothing sits blocked. Distil the ledger into a brief: one line per decision, verdict plus rationale, grouped by branch. Put it in chat, then one closing ask: "Proceed on this brief?" Nothing executes before that yes. After it, fold the brief into the project's knowledge base, or a log markdown file, wherever the project keeps its decisions.