Ask a coding agent to "add retry logic to the webhook handler" and you may get forty lines that retry everything — including requests that already succeeded — because you never said which failures matter. The agent didn't misunderstand you. It understood you exactly, and the one-line request was the bug. That gap between what you said and what you meant is what the grill me skill exists to close.
Grill me is an Agent Skill that flips the usual workflow: instead of implementing your idea straight away, the agent interviews you first, stress-testing the plan with pointed questions until every branch of it is decided. This article covers what it does, how to install it, how the questioning works, and when it's the wrong tool.
What is the grill me skill?
Grill me is an open-source skill by Matt Pocock, published in his mattpocock/skills collection. Its own description is short: "A relentless interview to sharpen a plan or design." You run it as the slash command /grill-me, followed by your idea or a pasted design doc.
A few details matter more than the tagline:
- You start it, not the agent. The skill sets
disable-model-invocation: true, so the agent never decides on its own to grill you — it runs only when you type/grill-me. - It's an interview, not a generator. Nothing gets written into your project while it runs. What you walk away with is the shared understanding — and a plan, if you ask the agent to write one down at the end.
- It works beyond Claude Code. It's a standard Agent Skill, so it runs in the other agents that read the same skill format.
The mental model: a senior engineer who won't let you start a sprint on a hand-wavy spec. Annoying in the moment. Worth it afterwards.
How to install and run it
The collection installs with the skills CLI:
- Open a terminal in the project where you use your agent.
- Run
npx skills@latest add mattpocock/skillsand pickgrill-mefrom the list (the CLI also takes--skill grill-meto install just that one). - In Claude Code, type
/grill-mefollowed by your idea, for example:/grill-me I want to add multi-tenant support to our billing service. - Answer the questions properly — not with "yes" and "probably".
- When the questioning ends, ask the agent to write the resulting plan to a spec file before any code is written.
If you manage skills by hand, you can instead copy the skill's folder into your skills directory (~/.claude/skills/ for Claude Code). Our guide on how to add skills to Claude Code covers where skills live and how they load.
Skills install per machine. If you work from a laptop and a desktop, each one needs the install — or install it once through loadout and let the agent on every paired machine put it in place.
How the questioning works
The questions aren't scattered follow-ups. The skill works through the plan like a decision tree: it asks about the open branches, numbers each question, and offers its own recommended answer, so you can agree in a word or push back. Each round builds on what you've already committed to, which is why the later questions get sharper. (Some people prefer one question at a time; the collection's docs suggest adding that preference to your CLAUDE.md.)
Take "add rate limiting to the API." A first round is typically about scope: which endpoints, which clients, what happens when the limit is hit. The next picks at data: where do counters live, what happens on restart, is the limit per key or per user. Later rounds reach what's easy to skip entirely, such as observability — how you'll know the limiter is working.
The output is the part people underrate. You finish with the decisions made, the open questions named, and a sequence for the work. That document is worth more than the interview itself.
If a feature can't survive a few rounds of grilling, it isn't ready to build.
When to use it, and when to skip it
Worth it: new features that touch several systems, architecture decisions with long-term costs, product specs where requirements haven't been pinned down, and design reviews where you want a second brain poking holes. It's especially useful right before you hand a task to an agent to run unattended: the grilling surfaces the edge cases the agent would otherwise guess at.
Skip it: one-line bug fixes, mechanical refactors, anything with an obvious implementation, and quick prototypes where speed is the point. Running it on "fix the failing test" is hiring a consultant to tell you your shoelace is untied.
The honest downside: it costs time up front — often ten to twenty minutes of real answering — and it can feel exhausting when you already know what you want. Lazy answers produce a lazy plan.
Grill me vs. plan mode vs. writing the spec yourself
These aren't rivals. They're stages.
| Workflow | What it produces | When to reach for it |
|---|---|---|
| Grill me skill | Decisions, open questions, sequencing | Ambiguous new work, before any code |
| Plan mode in Claude Code | An execution plan you approve | Right after the grilling, to sequence the work |
| Hand-written spec | A permanent document you control | Work whose documentation outlives the task |
Grill me comes first because it's the only one that interrogates. Plan mode turns what you've already said into a reviewable plan — valuable, but downstream of knowing what you want. A hand-written spec is the artifact you fully control, with one failure mode the others don't have: you can't see your own blind spots, and a solo spec documents them faithfully.
On anything non-trivial: grill, then plan, then code. On a two-line change, skip all three.
Getting the most out of a session
- Commit to answers. "It depends" just invites another round. Pick something; you can revise later.
- Run it early. Before you've written the migration, not after. Grilling a finished decision is regret with extra steps.
- Save the output. The final plan is a spec, a review artifact and an implementation prompt in one. Don't let it scroll away.
If grill me is your first Agent Skill, there's a wider ecosystem behind it: our best Claude Code skills roundup covers what else is worth installing, and the loadout marketplace lists reviewed skills you can install onto every machine you pair.
FAQ
What is the grill me skill?
An open-source Agent Skill by Matt Pocock that interviews you about a plan or design before implementation, working through each open decision until you and the agent share an understanding of it. You run it with /grill-me.
How do I install the grill me skill?
Run npx skills@latest add mattpocock/skills and pick grill-me, or copy the skill's folder into your skills directory (~/.claude/skills/ for Claude Code). Then type /grill-me followed by your idea.
Will Claude start grilling me on its own?
No. The skill disables model invocation, so it only runs when you type /grill-me.
Does the grill me skill create files in my project?
Not by itself — it's an interview. Ask the agent to save the resulting plan as a spec file when the questioning ends.
When should I skip the grill me skill?
For one-line fixes, mechanical refactors and quick prototypes. It pays off on new features, architecture decisions, product specs and design reviews, where ambiguity gets expensive later.