grill-me — the skill that refuses to build until you can defend your plan

Most coding agents fail in the same place: not where they write code, but where they assume requirements. You describe an idea in two paragraphs, the agent fills the gaps with the most plausible defaults, and the result is a competent build of something you did not ask for. The cost shows up later — a rework, a deleted branch, an hour of “that’s not what I meant.”

grill-me attacks that failure mode from the other direction. It is a Claude Code / Cowork skill whose entire job is to interview you about your plan until you and the agent share the same understanding of every decision in it — before a single line is written.

What it does

The whole skill is a short set of rules (the entire SKILL.md is under a hundred lines), which is exactly the point:

1. It treats your plan as a decision tree. It walks down each branch, resolving the dependencies between decisions one by one — “if we store it in Postgres, do we need migrations? if yes, who runs them?”
2. One question at a time. It never dumps a questionnaire. You answer, it acknowledges the decision in one or two sentences, and asks the next. The conversation stays narrow, so nothing gets overlooked and nothing overwhelms you.
3. Every question is a multiple-choice popup. It uses the AskUserQuestion tool, giving you 2–4 concrete options — the answers you would realistically pick — plus a free-text field. You click instead of composing. This is the difference between a skill you can actually use mid-flow and one that turns into a wall of text you skim.
4. It reads the codebase instead of asking you. If a question can be answered by looking at files, it goes and looks. You are only asked about things that are genuinely yours to decide — intent, priorities, trade-offs — not things the repository already answers.
5. When every branch is resolved, it ends with a concise summary of all decisions made. That summary is the artifact: a shared spec that both sides can point at.

The pain it removes

• “It built the wrong thing.” The dominant cost of agentic coding is not the writing, it is the discovery that the agent guessed at your requirements. grill-me moves that discovery to the front, where it is cheap: a few minutes of questions instead of an afternoon of rework.
• Vague prompts. If you cannot answer its questions, that is the feedback. A plan that cannot survive an interview is a plan the agent cannot execute well — the skill makes your vagueness visible to you before it becomes the agent’s problem.
• Context loss in long sessions. The final decision summary is a dense, structured document. It is easy to re-inject into a new session, or to paste into the next agent as the authoritative brief.
• Decision sprawl. Because decisions are resolved branch by branch and each one is acknowledged, you get a record of why each choice was made — not just what was chosen. That record is what code review, handoffs and future-you actually need.

How to use it

Install: drop the folder into your skills directory.

# the repo is just SKILL.md + a README
git clone https://github.com/RobMitt/grill-me-skill.git
cp -r grill-me-skill ~/.claude/skills/grill-me

Trigger: say “grill me”, or ask Claude to stress-test a plan, poke holes in a design, or interview you about an idea. It works best when you have some direction already — a feature you want to build, a refactor you are considering, an architecture you are weighing.

A typical session:

you:  I want to add a billing webhook to the API. Grill me.
agent: [popup] Where do webhooks fire from?
       A) A dedicated worker  B) Inline in the request  C) A queue (Bull/SQS)
you:  C
agent: Understood. [popup] What's the retry policy on failure?
       A) Exponential backoff, 5 retries  B) Fixed interval  C) No retry, DLQ only
...
agent: All branches resolved. Decisions: webhook via queue; exponential
       backoff with a DLQ; at-least-once delivery; signatures HMAC-SHA256.

Where it does not help

• Greenfield exploration with no direction. If you genuinely do not know what you want, it will interview you into a plan you are not sure you recognize. It clarifies intent; it does not generate it.
• Trivial changes. For a one-line fix the interview is overhead. Use it for decisions that have branches — features, architecture, anything you will live with.
• It is not a PRD generator. The output is a decision record, not a formatted spec document. Pair it with a writing skill if you need a document to hand to another team.
• It depends on your honesty. The interview is only as good as your answers. If you pick the first option every time to get it over with, you get a plan that reflects the agent’s defaults — which was the original problem.

Why the design is worth stealing

Even if you never install it, the mechanism is the valuable part. Three properties make it work:

• Structured over open-ended. Multiple-choice with an escape hatch beats “what do you want?” every time — it constrains the agent’s questions to real decisions and the user’s answers to real choices.
• Sequential over batched. One question at a time means each answer can inform the next, so the tree is actually pruned rather than enumerated.
• Evidence over asking. Reading the repo before asking turns “I have 40 questions for you” into “I have 6 questions for you,” and the 6 that remain are the ones only you can answer.

That is the shape of a good pre-implementation step in general, and grill-me is the cheapest way to get it.

How this article was written

Facts (install path, trigger, flow) are taken from the repository’s README.md and SKILL.md as of 2026-09-10. The assessment of where it helps and where it does not is our editorial judgment, based on how the rules in SKILL.md interact with typical agent workflows. The repository is small and stable; re-check the source before relying on any detail.