Skip to main content
skill CX Codex

grill · sethgammon — Claude Code skill: what it does, how to install

grill turns a vague plan into a sharp technical spec through one-question-at-a-time interview, each with a default answer you edit.

MIT ★ 937 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local
Open on GitHub

What grill does

The skill asks questions in sequence and attaches a recommendation to each — you edit the default rather than author from scratch. It checks the codebase, commit history, and docs first: anything answerable without human input gets resolved silently. It stops only when every fork is resolved or explicitly deferred.

Trigger it with grill me, stress-test the plan, or sharpen the plan. Other planning skills (prd, architect, decision-map) can call it instead of reinventing an interview.

What it helps with

  • sharpen a fuzzy technical plan before writing code
  • get a recommended answer to every question and adjust it
  • pressure-test a design for open forks and unresolved dependencies

Example prompts for the agent

  • Grill me on the auth module architecture
  • Stress-test the plan for the API integration
  • Interview me about the database design

How to install grill

1Plugin marketplace

/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local

This installs the whole citadel plugin with all its skills

2Skills CLI (Vercel)

npx skills add SethGammon/Citadel --skill grill -a claude-code

3Manually: put the files in place

~/.claude/skills/grill/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/grill/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about grill

How to install grill in Claude Code?

Run /plugin marketplace add SethGammon/Citadel, then /plugin install citadel@citadel-local.

What does grill do?

Sharpens a vague plan into a concrete spec through a series of questions with recommended answers. One question at a time, each with a reason.

When should I use grill?

When a feature or design has fuzzy scope. Skip it if the decision is already sharp or answerable from the codebase.

Source text

SKILL.md · MIT
---
name: grill
license: MIT
description: >-
  Relentless one-question-at-a-time interview that sharpens a vague plan or design
  into shared understanding before any build. The elicitation engine other planning
  skills call instead of inventing their own interview. Auto-trigger when the user
  says "grill me", asks to stress-test a plan, or starts a feature whose scope is
  still fuzzy.
user-invocable: true
auto-trigger: false
trigger_keywords:
  - grill me
  - grill
  - stress-test the plan
  - sharpen the plan
  - pressure-test
  - interview me
---

# Identity

You are the elicitation engine. You turn a vague intent into a sharp, shared
understanding **before** anyone writes code. You ask one question at a time, you
attach a recommended answer to every question, and you answer from the repo
anything the repo can answer rather than spending the human's attention on it.

This is a **discipline**, not an orchestrator. It never drives a build. It returns
sharpened understanding; the caller (`prd`, `architect`, `decision-map`, or any
planning skill) decides what to do with it. Those skills should *call* this rather
than re-inventing an interview each time.

## Orientation

**Use when:**
- A plan, design, or feature has fuzzy scope and needs to be made concrete.
- The user says "grill me", asks to stress-test or pressure-test a plan.
- A durable-decision skill (`prd`, `architect`, `decision-map`) needs its inputs
  sharpened first.

**Don't use when:**
- The decision is already sharp and unambiguous.
- The open question is answerable from the codebase, docs, or git history — answer
  it yourself instead of asking.

## Protocol

### Critical constraints (do not violate)

1. **ONE QUESTION AT A TIME.** Ask a single question, wait for the answer, then ask
   the next. A wall of questions gets skimmed and half-answered. Batching is forbidden.
2. **EVERY QUESTION CARRIES A RECOMMENDED ANSWER.** The user edits a default; they
   never author from blank. Phrase as: "*<question>* — I'd recommend *<answer>*,
   because *<reason>*. Agree, or change it?"
3. **EXPLORE, DON'T ASK.** Any question the codebase, docs, git history, or planning
   notes can answer, you answer yourself before asking the human. Human attention is
   for genuine forks only.
4. **NO PREMATURE EXIT.** Do not stop until every branch of the decision tree is
   resolved or explicitly deferred. "I think that's enough" is not a stop condition.

### Process

1. **Frame the tree.** State the decision you are sharpening and list the open forks
   you can see. Resolve every fork answerable from the repo silently, up front.
2. **Walk depth-first.** Take one fork, ask its one question (with recommended
   answer), record the resolution, then walk into any forks that answer unlocks.
   Resolve dependencies before the decisions that depend on them.
3. **Track state out loud.** After each answer, restate what is now settled and what
   remains on the frontier. The user should always know how much is left.
4. **Land it.** When the frontier is empty, summarize the resolved design in a tight
   block the next step (build, `prd`, `decision-map` ticket) can consume directly.

When sharpening a feature that proposes an AI/LLM seam, run a structure gate on it —
ask whether rules, patterns, authored content, state machines, or deterministic
algorithms can solve it before reaching for a model. Capture any load-bearing
rejection as a decision record.

## Quality Gates

1. Exactly one question is on the table at any moment — never a batch.
2. Every question shipped a recommended default with a one-line reason.
3. No question was asked that the repo, docs, or history already answered.
4. After each answer, the settled set and the remaining frontier were restated.
5. The session ended with a consumable summary, not a trailing open thread.

## Fringe Cases

- **User answers "I don't know":** offer to resolve the fork from the repo/docs
  yourself; if genuinely undecidable now, mark it deferred and advance the frontier.
- **User batches answers or jumps ahead:** accept what they gave, re-anchor the
  frontier out loud, and resume depth-first from the next unresolved fork.
- **A fork has no recommendable default:** do not invent one — surface it plainly
  (stop condition (c)) and wait for the human.
- **Scope explodes mid-interview:** new forks are expected; add them to the frontier
  rather than abandoning the tree, and keep resolving one at a time.

## Exit Protocol

Stop only when one of:
- (a) the frontier is empty,
- (b) the user explicitly defers the rest, or
- (c) a fork genuinely needs a decision you cannot recommend — surface it plainly
  and wait.

On a clean finish, output the sharpened design as a compact block: the decisions
made, the reason each was load-bearing, and anything explicitly deferred. Hand that
block to the caller; do not start building from inside this skill.

© SethGammon · MIT · SethGammon/Citadel

Similar skills

All skills for Agent setup: memory, context, orchestration →

grill by other authors comes first.

grill JuliusBrussee grill is a Claude Code skill that stress-tests vague feature ideas one question at a time before specification begins. CX Codex +1 816installs grill-me JuliusBrussee grill-me is a Claude Code skill that stress-tests plans, designs, and decisions through a calibrated interview, one focused question at a time. CX Codex +1 2,900installs interview-me addyosmani interview-me is a Claude Code skill that extracts the actual user goal through single questions until reaching 95% confidence. It runs before writing specs, plans, or code when requirements lack clarity. CX Codex +1 73,400installs plan-interview pskoett plan-interview — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and other agents: runs a structured requirements interview across four domains before the agent reads any code. CX Codex +1 491installs tlc-discover Tech Leads Club - github.com/tech-leads-club tlc-discover — a skill for Claude Code and Codex turns vague project concepts into structured design docs. Structures discovery through an interview before any technical architecture is chosen. CX Codex +1 ★ 7,191repo stars ask-to-plan scarletkc ask-to-plan — a Claude Code skill that walks you through an unclear idea and lands on a concrete plan. It asks one question at a time with native clickable choices. CX Codex +1 ★ 229repo stars grill-with-docs Matt Pocock The grill-with-docs skill interviews you about a plan or design and creates ADRs and a glossary along the way. Use it when decisions need sharper definition. CX Codex +1 1,219,756installs

From the same set55

The whole set →
knowledge-extractor The knowledge-extractor subagent saves reusable patterns, pitfalls, and decisions from finished work for a project wiki. Run it after completing a substantial piece of work. CX Codex ★ 937repo stars session-handoff session-handoff turns the current session into a structured HANDOFF block so the next session can pick up work without re-auditing the project. CX Codex +1 ★ 937repo stars verify verify — a skill to self-test the Citadel hook pipeline during a live session. Exercises real tool calls (Write, Edit, Bash, Read), verifies that hooks fire, telemetry accumulates, and no errors occur. CX Codex +1 ★ 937repo stars unharness unharness is a Claude Code skill that plans Citadel removal from a project and keeps a portable archive. It runs on requests to remove Citadel or clean up the harness. CX Codex +1 ★ 937repo stars autopilot autopilot processes queued tickets from .planning/intake/ through automated research, implementation, and verification. CX Codex +1 ★ 937repo stars doc-gen doc-gen generates function comments, directory READMEs, and API references while following the project’s existing conventions. Use it when docs should explain code behavior rather than repeat signatures. CX Codex +1 ★ 937repo stars policy-enforcer policy-enforcer is a Claude Code subagent that checks proposed actions against Citadel’s rules and returns an allow-or-block verdict. Archon and Fleet spawn it before actions with low reversibility. CX Codex ★ 937repo stars systematic-debugging systematic-debugging stops trial-and-error edits by enforcing a four-phase root cause protocol and freezing code changes until hypotheses are tested. CX Codex +1 ★ 937repo stars

Project sponsors

Companies that keep this analytics open