Planning, Decisions, and Delivery Skills

Need	Skill
Sharpen a loose plan	`$grill-me`
Turn a rough idea into an agreed design before any code	`$brainstorming`
Clarify a task in one batch of questions, then execute it yourself	`$ask-first`
Write an agreed design up as a plan another session can execute	`$writing-plans`
Work through a written plan phase by phase	`$executing-plans`
Stress-test a plan, decision, or raw idea	`$grilling`
Interview in wide rounds instead of one question at a time	`$batch-grill-me`
Extract knowledge only another person holds	`$to-questionnaire`
Sharpen a plan and create ADRs/glossary material	`$grill-with-docs`
Interview within this workspace's workflow format	`$loop-me`
Compare a consequential decision from several perspectives	`$llm-council`
Synthesize the current discussion into a spec on the tracker	`$to-spec`
Split a plan or spec into tracer-bullet tickets with blocking edges	`$to-tickets`
Chart work too big for one session as decision tickets, resolved one at a time	`$wayfinder`
Process incoming issues and external PRs	`$triage`
Hand the current context to another agent	`$handoff`
Hand off to a fresh background agent that starts immediately	`$claude-handoff`
Write the session's state to a file a future session reads cold	`$handoff-doc`
Give a project a persistent vault of memory, decisions, handoffs, and intake shared by Claude Code and Codex	`$setup-project-vault`

Choosing among the close pairs

Several skills here interview you and three hand work off. The distinctions:

$grill-me asks one question at a time and follows your answers; $batch-grill-me fires a whole round of frontier questions at once and maps them as a design tree. Pick batch when you would rather answer ten things in one sitting than be led; pick $grill-me when each answer should change the next question. $grilling is the general stress-test when neither cadence matters.
The grill family attacks a plan you already hold; $brainstorming starts further back, from a rough idea, and works toward a design you both agree on before anything is built. $ask-first is the light version of the same instinct — a batch of clarifying questions, then it does the task. Reach for $ask-first when the work is small and only the requirements are fuzzy, $brainstorming when the shape of the thing is genuinely undecided.
$to-questionnaire is not an interview at all — it produces a document for someone else to fill in. Use it when the blocking knowledge lives in another person's head; use the grill family when it lives in yours.
$handoff writes the current context out for whatever agent picks it up next; $claude-handoff immediately spawns a fresh background agent to continue; $handoff-doc writes a durable file at a path you name, for a session that may start days later. Pick $handoff when the next session is a human decision or a different tool, $claude-handoff when you want work continuing right now, and $handoff-doc when the artifact should outlive the conversation.
$setup-project-vault is not a handoff; it builds the place handoffs live. Run it once per project, and the vault's own AGENTS.md then governs handoffs, decisions, and memory in every later session. Choose $handoff-doc for a one-off handoff file in a project without a vault. Do not use it to search or edit notes in an existing vault; that is /obsidian-vault.

Plans as documents

$writing-plans turns an agreed design into a plan file with enough context that a session which never saw the discussion can carry it out; $executing-plans is the other end, working that file phase by phase. They are a pair, and both assume the design is settled — run $brainstorming first when it is not. Choose $to-tickets instead when the work should live on the issue tracker as separately deliverable slices rather than in one document.

Setup and routing

$setup-matt-pocock-skills: one-time setup for the issue tracker, triage vocabulary, and domain-doc layout used by this engineering workflow family.
$ask-matt: route an engineering situation to the relevant installed workflow.

Shipping an Apple app (Claude Code only)

Ships in the apple-skills plugin. These cover the business and release side of an App Store product — the code side lives in the development guide, and Apple's visual design is /design in the design guide.

$product-development: end-to-end product work — market research, competitive analysis, PRD, architecture spec, UX. The widest of these; the others below are single stages of it.
$release-review: a senior-level pre-release audit for security, privacy, UX, and distribution issues. Run it before submission, after the app is built.
$app-store: App Store optimization — descriptions, screenshots, keywords, review responses, promotion.
$monetization: pricing model, tiers, trials, and their implementation for iOS/macOS apps.
$growth: user acquisition, analytics, press outreach, community, indie business ops.
$legal: privacy policies, terms, EULAs, GDPR/CCPA compliance documents.

Delivery chain

$grill-me when the idea is still soft, or $wayfinder when the work is too large for one session and the route is still foggy.
$to-spec when the decisions are clear — it synthesizes, it does not interview.
$to-tickets when work needs parallel or incremental delivery.
$implement for one ready ticket.
$code-review before handoff or merge.

Skip stages that add no new information. Use $llm-council for genuine decisions with stakes and alternatives, not factual questions or routine validation.