---
title: Grill Me Skill for Claude Code
canonical: https://skillselion.com/skills/mattpocock/skills/grill-me
content_type: text/markdown
description: grill-me is a Claude Code skill that runs a relentless one-question-at-a-time interview to stress-test a plan or design until the developer and the agent reach.
---

# Grill Me Skill

Title: Grill Me Skill for Claude Code

> grill-me is a Claude Code skill that runs a relentless one-question-at-a-time interview to stress-test a plan or design until the developer and the agent reach.

Canonical: https://skillselion.com/skills/mattpocock/skills/grill-me

Grill Me is Matt Pocock's planning skill for Claude Code. Type /grill-me and the agent asks every question whose prerequisites are already settled, numbers the questions, recommends an answer for each, and waits before continuing. It checks the codebase for answers first and blocks implementation until you confirm its understanding.

grill-me is a Claude Code skill that runs a relentless one-question-at-a-time interview to stress-test a plan or design until the developer and the agent reach a confirmed shared understanding.

## Key facts

- Installs: 1,558,318
- GitHub stars: 326,014
- Author: mattpocock
- Repository: mattpocock/skills
- Install command: `npx skills add https://github.com/mattpocock/skills --skill grill-me`
- Last updated: November 13, 2026

## What Grill Me does

Run a relentless one-question-at-a-time interview that stress-tests a plan or design before any code is written.

How do you catch the hidden assumptions in a plan before an agent starts building it?

A plan refined through an exhaustive interview, with every open decision explicitly answered by the developer and shared understanding confirmed before any implementation begins.

Best for: Developers about to hand a non-trivial plan or design to an agent who want every assumption and open decision made explicit first.

Not for: Skip it for trivial or fully-specified tasks where an interview would add ceremony without changing any decision.

- User-invoked slash command whose entire body is: run a /grilling session
- The session asks questions one at a time, each with a recommended answer, waiting for feedback before continuing
- Facts are looked up in the codebase; only genuine decisions are put to the user
- The plan is not enacted until the user confirms shared understanding

## SKILL.md

Call the Skill tool with "grilling".

## Deep dive: how does grill-me actually work?

We read both files line by line at commit `5863806` of mattpocock/skills on November 14, 2026, and verified our grill-me catalog copy matches the repository byte for byte. We first published this dive against commit `885e2ca`. Since then grill-me itself has not changed; grilling has gained a two-question example of a round, a rule about how each question is worded, and a note on how its fact-finding sub-agents start.

## grill-me at a glance

1. **The installed file is a seven-line shim** that calls a sibling skill named grilling.
2. **You trigger it, the model cannot**, though the method skill underneath keeps its own autonomy.
3. **The method maps your plan as a design tree**, where every decision branches into the decisions that hang off it.
4. **Questions arrive in rounds**, numbered, each with the agent's recommended answer attached.
5. **Facts are the agent's job, decisions are yours**, enforced by an explicit division of labor.
6. **Done means an empty frontier**, and the agent must not act until you confirm shared understanding.

## 1. The installed file is a seven-line shim

The SKILL.md behind {{installsExact}} installs contains one working sentence:

> Call the Skill tool with "grilling".
> Source: SKILL.md, full file at [skills/productivity/grill-me](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grill-me/SKILL.md#L7)

That is not laziness, it is routing. The repo keeps one method skill, [grilling](/skills/mattpocock/skills/grilling), and points two trigger shims at it: grill-me for plans, and [grill-with-docs](/skills/mattpocock/skills/grill-with-docs) for plans that also produce a glossary and ADRs. Three workflow skills call it too: [improve-codebase-architecture](/skills/mattpocock/skills/improve-codebase-architecture), triage and wayfinder. The shim owns the trigger phrase you actually say ("grill me"); the sibling owns the procedure. One dependency to know about: the seven-line file has nothing to fall back on, so grill-me only works when grilling is present too.

The shim took its current shape on 2026-08-15, when the author standardized every cross-skill call in the repo on the explicit phrase "call the Skill tool". Before that, delegation phrasing varied per skill.

## 2. You trigger it, the model cannot

The frontmatter carries a switch most skills never set:

> disable-model-invocation: true
> Source: SKILL.md, [frontmatter](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grill-me/SKILL.md#L4)

The bundled OpenAI agent manifest repeats the decision for other platforms:

> policy:
>   allow_implicit_invocation: false
> Source: agents/openai.yaml, [policy block](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grill-me/agents/openai.yaml#L4-L5)

The lock sits on the trigger skill only. Your agent can never fire grill-me by itself, which is the right call for a skill whose entire output is questions aimed at you, and the opposite of the [wide-trigger frontmatter behind find-skills](/skills/vercel-labs/skills/find-skills#deep-dive), where matching as many requests as possible is the point. But grilling, the method underneath, carries no such flag: its description tells the agent to use it "when the user wants to stress-test their thinking". The phrase belongs to you; the method keeps its own judgment.

## 3. The method maps your plan as a design tree

The delegated file, grilling, opens with the model of the conversation:

> Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it.
> Source: grilling SKILL.md, ["design tree"](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L6)

The tree is what separates this from a generic "ask me clarifying questions" prompt. Decisions have prerequisites, and the skill makes the agent track them instead of firing questions in whatever order they occur to it.

A small aside we enjoyed: the author shipped a patch whose changelog reads "grilling: remove em-dashes from `SKILL.md`, replacing them with colons and semicolons so the instructions read as plain text" ([changeset](https://github.com/mattpocock/skills/blob/885e2ca4d842d139e9aef4e48d366c63cb1b8013/.changeset/grilling-remove-em-dashes.md#L5)). Even instruction files are getting the AI-tell scrubbed out of them now.

## 4. Questions arrive in rounds

The pacing rule is the sharpest engineering in the file:

> Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round.
> Source: grilling SKILL.md, ["rounds"](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L8)

Every question ships in a fixed format, with the agent's own recommendation attached:

> ❓ **Q1** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>
>
> ➡️ <your recommended answer>
> Source: grilling SKILL.md, [question format](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L13-L15)

The file's own example shows two questions in one round, split by a rule line, and the next line makes the recommendation cheap to accept:

> Word each question so "yes" accepts your recommended answer.
> Source: grilling SKILL.md, [wording rule](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L24)

You can clear a round by agreeing, instead of writing an essay. The ordering discipline is explicit too: a question whose answer depends on another question still open in the current round "belongs to a _later_ round, not this one." Each answered round reshapes the tree and unblocks the next frontier.

## 5. Facts are the agent's job, decisions are yours

Our favorite paragraph in the file draws a line most planning prompts blur:

> Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent with a fresh context window to find it; don't ask the user for anything you could look up yourself.
> Source: grilling SKILL.md, ["facts"](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L28)

"A fresh context window" is the newer wording: the lookup runs in a sub-agent that starts clean, not one that inherits the whole interview. The same paragraph adds a scheduling trick: a running sub-agent exploration counts as an unsettled prerequisite, so only the questions downstream of it wait. The rest of the frontier gets asked immediately. The result is an interview that never stalls on a lookup and never wastes your time asking you to run `ls`.

## 6. Done means an empty frontier

The exit condition is testable, not vibes:

> The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding.
> Source: grilling SKILL.md, [exit condition](https://github.com/mattpocock/skills/blob/5863806dd4e15c63174bee4e7515a4256792ecfa/skills/productivity/grilling/SKILL.md#L30)

Note the final gate: even with an empty frontier, the agent still needs your explicit confirmation before acting. The plan belongs to you twice over.

**Tools it drives:** the Skill tool (to load grilling) and sub-agents for fact-finding. It never edits a file.

**Behavior change, before and after:**

| You say | Without grill-me | With grill-me |
|---|---|---|
| "Grill me on this plan" | The agent nods along and starts building | Numbered question rounds, each with a recommended answer, until no branch of the plan is silently assumed |
| "We should add a Postgres cache here" | "Great idea" and an implementation | The frontier fills with the decisions hanging off that one: invalidation, local dev story, who owns the schema |

**The fine print worth knowing:**

- The shim depends on grilling being installed; its seven lines contain nothing else to run.
- The lock on autonomy covers grill-me only. grilling's own description invites the agent to fire it when you seem to want your thinking stress-tested.

## Should you install grill-me?

Install it if you have ever watched an agent enthusiastically build the wrong thing. The design-tree method is the strongest planning-interview file we have read: recommended answers keep the rounds fast, and the fact-finding rule stops it from outsourcing lookups to you. Skip it if your tasks are small enough that the plan is the prompt. Either way, it never fires on its own; "grill me" has to enter your vocabulary.

```
npx skills add https://github.com/mattpocock/skills --skill grill-me
```

## Grill Me FAQ

### Do you need to install both grill-me and grilling?

Practically, yes. The shim's only instruction calls grilling by name, so with no grilling installed there is nothing to run. Install both, or install grilling alone and trigger the method directly.

### Does grill-me work outside Claude Code?

The bundle ships an `agents/openai.yaml` interface manifest alongside SKILL.md, so the same skill folder serves OpenAI-compatible agents. The method file itself is plain markdown any agent runtime can load.

### What is the grill-me skill?

grill-me is the install id and slash command for Grill Me. Type /grill-me in Claude Code and the skill asks every question whose prerequisites are already settled, then waits for your answers before it starts implementing.

### How do I use Grill Me in Claude Code?

Type /grill-me when a plan needs sharpening before implementation. It is user-invoked only (disable-model-invocation: true), so the agent never fires it on its own, and every question arrives with the answer the agent recommends. It keeps going until every branch is resolved, and starts building only once you confirm shared understanding.

### What does the grill-me skill do?

It runs a grilling session: the agent interviews you one question at a time about every aspect of your plan, recommends an answer for each question, and will not start building until you confirm shared understanding.

### How is grill-me different from the grilling skill?

grill-me is the user-invoked slash command; its whole body is to run a /grilling session. grilling is the model-invoked skill that holds the interview behavior and can fire autonomously on 'grill' trigger phrases.

### When should I use grill-me?

Before implementing a non-trivial plan or design. The interview surfaces hidden assumptions and forces explicit decisions while they are still cheap to change.

## Machine access

- [Sitemap](https://skillselion.com/sitemap.xml)
- [llms.txt](https://skillselion.com/llms.txt)
- [llms-full.txt](https://skillselion.com/llms-full.txt)
- [Developer resources](https://skillselion.com/developers)
- [OpenAPI spec](https://skillselion.com/openapi.json)
- [MCP handshake](https://skillselion.com/.well-known/mcp)
- [API catalog](https://skillselion.com/.well-known/api-catalog)
- [AI catalog](https://skillselion.com/.well-known/ai-catalog.json)
- [Pricing](https://skillselion.com/pricing.md)
- [Auth](https://skillselion.com/auth.md)
- [AGENTS.md](https://skillselion.com/AGENTS.md)
- [Contact](https://skillselion.com/contact)
- [Home](https://skillselion.com/)
