New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Grill Before Spec

by JuliusBrussee in JuliusBrussee/cavekit

Interrogates a vague idea one question at a time, recommending an answer each round and recording results as goals and constraints before a spec is written.

MITAuto-check passedAgent Workflows

Install Grill Before Spec

skills CLI
$ npx skills add JuliusBrussee/cavekit --skill grill -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install JuliusBrussee/cavekit grill --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/JuliusBrussee/cavekit.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/grill .claude/skills/grill && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
grill
GitHub stars
1.2k
Token cost
~812 tokens
SKILL.md length
429 words
Files
1
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

Interrogates a vague idea one question at a time, recommending an answer each round and recording results as goals and constraints before a spec is written.

  • Works in 3 steps: How well does user know this domain?… → How locked is the idea? (exploring vs… → Pressure wanted: light / normal / brutal.
  • Pressure-testing a one-sentence idea before writing a spec
  • SKILL.md covers WHEN TO GRILL, CALIBRATE FIRST, QUESTION LADDER and ANSWER FORMAT, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

This skill stress-tests a fuzzy idea before it becomes a spec. After a quick read of your domain knowledge, how locked the idea is and how much pressure you want, from light to brutal, the agent climbs a ladder of seven questions: goal, done, boundary, lock, surface, edge and unknown. It asks one at a time, always with a recommended answer so you can simply agree, and each answer lands in the goal section or the constraints section of the spec. Unknowns are parked as marked items instead of being guessed.

It stops as soon as the spec would be unambiguous rather than asking all seven by reflex, and it is skipped for typo-sized changes. It is finished when the goal is one line with one reading, the constraints cover every stated or implied non-negotiable, and every blocking unknown is answered or parked. The agent then hands a compact block to the spec skill, which is the only one allowed to write the spec file, and recommends research when an unknown needs outside information.

When your agent uses it

  • Pressure-testing a one-sentence idea before writing a spec
  • Challenging a plan that can be read in several ways
  • Collecting goals and constraints before starting a new spec

Example prompts

  • “Grill me on this idea: a CLI that syncs our docs folder to a static site.”
  • “Stress-test my plan to move billing onto a queue before I write the spec.”
  • “Interview me before I spec the notifications feature, and keep the pressure light.”

Requirements

  • The spec skill from the same plugin, which writes the result

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. How well does user know this domain? (sets question depth)
  2. How locked is the idea? (exploring vs committed)
  3. Pressure wanted: light / normal / brutal.

What it can do on your machine

Read from SKILL.md and the folder at commit 7421e87. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Grill Before Spec loads about 812 tokens when it runs. Until then it costs about 120 tokens; SKILL.md has 429 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~120
When it runs · the whole SKILL.md, loaded when a task matches
~812

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from JuliusBrussee/cavekit at commit 7421e87, republished under its MIT licence (© JuliusBrussee). 429 words, ~812 tokens.

Download SKILL.mdSave it as .claude/skills/grill/SKILL.md (or your agent's skills folder).
name
grill
description
Calibrated interrogation of a fuzzy idea before it becomes a spec. Asks one question at a time, recommends an answer, and lands each answer in §G (goal) or §C (constraints) — unknowns parked as `?` items, never guessed. The cheapest place to kill a bad idea is before §T exists. Triggers when the user has a vague idea, says "grill me", "stress-test this", "challenge my plan", "interview me before I spec", or invokes /ck:grill. Defers the actual write to the spec skill.

grill — sharpen idea before spec

One question at a time. Every answer lands in a § or gets parked ?. Never guess a constraint into existence.

Plan-then-execute guesses the fuzzy parts & builds the wrong thing. Grill drags the fuzz into §G/§C before a single §T row exists. A bad assumption caught here costs one question. Caught in §B it costs a bug.

WHEN TO GRILL

  • Idea is one sentence & you can feel the holes.
  • Multiple readings of the goal exist & you are about to pick one silently.
  • Before /spec new on anything non-trivial.
  • User asks to be challenged / stress-tested.

Skip for a typo or a one-line fix. Grill scales to uncertainty, ⊥ to ego.

CALIBRATE FIRST

One opening read, not a quiz:

  1. How well does user know this domain? (sets question depth)
  2. How locked is the idea? (exploring vs committed)
  3. Pressure wanted: light / normal / brutal.

Match it. Brutal grilling on a half-formed idea just demoralizes. Light grilling on a committed plan misses the load-bearing flaw.

QUESTION LADDER

Climb in order. Each rung, ask one question, recommend an answer, wait.

  1. Goal — what must the code do, in one line? (→ §G)
  2. Done — how do we know it works? name the observable. (→ §C / future §V)
  3. Boundary — what is explicitly out of scope? (→ §C)
  4. Lock — what tech/lib/pattern is non-negotiable? what is forbidden? (→ §C)
  5. Surface — what does the outside world touch — cmd, api, file, env? (→ §I)
  6. Edge — the one input that breaks the happy path? (→ future §V)
  7. Unknown — what do we not know yet? (→ park as ? §C bullet)

Stop climbing the moment the spec would be unambiguous. Do not ask all seven by reflex.

Show full SKILL.md (153 more words)Show less

ANSWER FORMAT

Each question carries a recommended answer so the user can grunt "yes" & move:

Q: auth — session cookie or JWT? rec: JWT — stateless, you named horizontal scaling as a §C. (a) JWT (b) cookie (c) something else?

HANDOFF

When done, emit a compact block — goal line, constraint bullets, surfaced unknowns as ? — and hand to the spec skill to write §G/§C. Grill proposes; spec is the sole mutator. Never write SPEC.md directly.

WHEN TO STOP

Done when ALL hold:

  • §G is one line, one reading, zero "or maybe".
  • §C covers every non-negotiable the user stated or implied.
  • Every blocking unknown is either answered or parked as an explicit ?.

Unresolved blocking unknown that needs the outside world → recommend /research, not a guess.

BOUNDARIES

  • ⊥ make product decisions for the user. Recommend, never decide.
  • ⊥ write SPEC.md. Hand structured answers to spec.
  • ⊥ ask in bulk. One question, one recommendation, wait.
  • ⊥ grill a trivial change. Right-size or skip.

© JuliusBrussee, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/grill of JuliusBrussee/cavekit.

Open the folder on GitHubat commit 7421e87

Compare with similar skills

Grill Before Spec next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Grill Before Spec compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Grill Before Spec this skillJuliusBrussee/cavekit1.2k—~812Automated safety check: PassMIT
Brainstorming Before BuildingjnMetaCode/superpowers-zh8.3k—~1.8kAutomated safety check: PassMIT
Extracting Requirementsprime-radiant-inc/iterative-development181—~2.7kAutomated safety check: PassApache-2.0
GSD Phase Discussionopen-gsd/gsd-core10k1 repos~1.5kAutomated safety check: WarnMIT
Interview-Driven Spec Writerposhan0126/dotclaude871—~804Automated safety check: PassMIT
Spec-Driven DevelopmentLichAmnesia/lich-skills234—~3.5kAutomated safety check: PassMIT

Similar skills

  • Brainstorming Before Building

    jnMetaCode/superpowers-zh

    Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.

    8.3k GitHub stars~1.8k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

  • Extracting Requirements

    prime-radiant-inc/iterative-development

    Reads human-written spec documents and produces per-epic requirement files with proof obligations plus behavior scenarios with stable IDs, using parallel chunked extraction.

    181 GitHub stars~2.7k tokensUpdated 4 mo ago
    Agent WorkflowsAuto-check passed

  • GSD Phase Discussion

    open-gsd/gsd-core

    Asks adaptive questions about a project phase and records the decisions in a CONTEXT.md that later research and planning agents can act on without asking again.

    10k GitHub starsUsed in 1 repo~1.5k tokens
    Agent WorkflowsAuto-check: warnings

  • Interview-Driven Spec Writer

    poshan0126/dotclaude

    Interviews you about scope, behavior, edge cases and verification, then writes a self-contained SPEC.md that a fresh session can implement without this conversation.

    871 GitHub stars~804 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed

  • Spec-Driven Development

    LichAmnesia/lich-skills

    Runs a gated Spec, Plan, Build, Test, Review, Ship workflow so non-trivial changes are specified, verified and reviewed before they ship, with a named artifact per phase.

    234 GitHub stars~3.5k tokensUpdated 4 mo ago
    Agent WorkflowsAuto-check passed

  • Deep Interview

    Yeachan-Heo/oh-my-claudecode

    Interviews you with Socratic questions and an ambiguity score until a vague idea becomes a clear spec, then holds execution until you approve.

    40k GitHub stars~12k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

More from JuliusBrussee/cavekit

All 8 skills in this repo

  • Backprop: Bug-to-Spec Protocol

    JuliusBrussee/cavekit

    After a bug is found, traces its root cause and feeds a new testable invariant back into the project spec so the bug class can't recur.

    1.2k GitHub stars~653 tokensUpdated 1 mo ago
    Auto-check passed

  • Caveman Spec Compression

    JuliusBrussee/cavekit

    Compresses SPEC.md writes and spec-referencing prose into terse, symbol-heavy fragments that drop articles, filler and hedging while keeping facts intact.

    1.2k GitHub stars~721 tokensUpdated 1 mo ago
    Auto-check passed

  • Spec Drift Check

    JuliusBrussee/cavekit

    Read-only detector that compares SPEC.md with the code and reports invariant, interface and task drift grouped by severity, without changing anything.

    1.2k GitHub stars~666 tokensUpdated 1 mo ago
    Auto-check passed

  • Adversarial Spec Review

    JuliusBrussee/cavekit

    Builds a skeptical reviewer grounded in the codebase and research notes to try to refute a spec before any code is written, citing file:line evidence and ending in a go or no-go gate.

    1.2k GitHub stars~959 tokensUpdated 1 mo ago
    Auto-check passed

  • Deepen Module Design

    JuliusBrussee/cavekit

    Scans the code a spec touches for its shallowest module, then proposes a refactor that hides more behind a smaller interface without changing behavior.

    1.2k GitHub stars~1k tokensUpdated 1 mo ago
    Auto-check passed

  • Research

    JuliusBrussee/cavekit

    Gather external knowledge the spec needs and distill it into §R — the durable research log — so build grounds in facts instead of hallucinating library behavior.

    1.2k GitHub stars~782 tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Grill Before Spec

What does Grill Before Spec do?

Interrogates a vague idea one question at a time, recommending an answer each round and recording results as goals and constraints before a spec is written. This skill stress-tests a fuzzy idea before it becomes a spec. After a quick read of your domain knowledge, how locked the idea is and how much pressure you want, from light to brutal, the agent climbs a ladder of seven questions: goal, done, boundary, lock, surface, edge and unknown.

When should I use Grill Before Spec?

Grill Before Spec fits situations like: pressure-testing a one-sentence idea before writing a spec; challenging a plan that can be read in several ways; collecting goals and constraints before starting a new spec.

How do I install Grill Before Spec in Claude Code?

Run `npx skills add JuliusBrussee/cavekit --skill grill -a claude-code`. Or copy the skill folder (skills/grill in JuliusBrussee/cavekit) into .claude/skills/grill in your project. Claude Code loads it when a task matches its description.

How do I install Grill Before Spec in Codex?

Run `npx skills add JuliusBrussee/cavekit --skill grill -a codex`. Or copy the skill folder (skills/grill in JuliusBrussee/cavekit) into .agents/skills/grill in your project. Codex loads it when a task matches its description.

Can I use Grill Before Spec in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add JuliusBrussee/cavekit --skill grill -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/grill, .gemini/skills/grill, .github/skills/grill and .opencode/skills/grill in your project.

What does Grill Before Spec need to run?

SKILL.md names no scripts, command-line tools or credentials: Grill Before Spec is instructions for the agent only. Our summary lists: The spec skill from the same plugin, which writes the result.

Does Grill Before Spec access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Grill Before Spec safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Grill Before Spec use?

Grill Before Spec is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Grill Before Spec use?

About 812 tokens (SKILL.md is roughly 3.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Grill Before Spec?

Skills that share tags, products or a category with Grill Before Spec: Brainstorming Before Building (jnMetaCode/superpowers-zh, 8.3k stars), Extracting Requirements (prime-radiant-inc/iterative-development, 181 stars), GSD Phase Discussion (open-gsd/gsd-core, 10k stars) and Interview-Driven Spec Writer (poshan0126/dotclaude, 871 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Grill Before Spec?

JuliusBrussee (a GitHub user) maintains it in JuliusBrussee/cavekit, which has 1,152 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on August 14, 2026.

Source: JuliusBrussee/cavekit on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.