The "grill-me" Skill Deep Dive — Matt Pocock's 3-Line Agent Skill That Has AI Coding Agents Ask 18–24 Sequential Questions Until Full Alignment, Eliminating the "Plan → Build → Re-Plan" Inefficiency Loop A Read-Through of the Zenn Article (ryonakae), Best Paired With Opus 4.6 / Sonnet at Medium Effort

Matt Pocock's grill-me is an Agent Skill that fundamentally reshapes AI coding-agent behavior with just three lines of instruction (Zenn writeup by ryonakae).

Four takeaways:

1. Just three lines switch the agent into "grill the user thoroughly" mode
2. 18–24 questions per session — scope, dependencies, and design decisions dug into progressively
3. Eliminates plan-mode inefficiency — no more "plan → build → re-plan" token waste
4. Best with Opus 4.6 / Sonnet at medium effort; question fatigue exists but downstream re-work is worse

Traditional Claude / Cursor plan mode:

1. User: "Build feature X."
2. Agent: presents a detailed plan
3. User: "OK, go ahead."
4. Agent: implements
5. User: "Oh, that's not what I meant here."
6. Agent: adjusts plan and re-implements
7. Loop → wasted tokens and time

The real problem: human and AI aren't fully aligned when the plan is agreed to — you don't discover misalignment until code lands. Plan mode presents plans, but you don't start with a deep understanding of them.

Invert the interaction: the agent grills you, and code generation waits until complete mutual understanding is achieved.

Observations from ryonakae's article:
- 18–24 questions per session
- 2–5 options per question (no forced free-form answers)
- Questions proceed from scope → dependencies → design decisions in progressively deeper stages

Example questions (extrapolated):
1. "Does this feature involve user auth?"
- A) Yes, existing Better Auth
- B) Yes, new implementation
- C) No, public feature
2. "Do you need data persistence?"
- A) Yes, D1 / Postgres
- B) Yes, KV / Redis
- C) No, in-memory
3. ...(continues)

After questioning ends: the agent already has full context, and implementation proceeds frictionlessly. The plan → build → replan loop never has a chance to start.

grill-me is deliberately short — very Matt-Pocock:

Three critical parts:
1. "Before writing any code" — hard delay of code generation
2. "Thorough sequential questions" — not one-shot, progressive depth
3. "2–5 options per question" — reduce answer friction by offering choices

That three-line instruction reshapes the whole agent design — it's a clean demonstration of Anthropic Claude Skills' philosophy of "thin wrappers change behavior."

Everything is resolved in the questioning phase — no "wait, that's wrong" during implementation. Both tokens and time saved.

The user's own requirements crystallize through the questioning. Sometimes the AI's question pulls out a "oh, I hadn't thought about that" — the act of being asked is itself value creation.

18–24 Q&A pairs form natural design documentation — during later review or when explaining to someone else, "why is it built this way?" stays traceable.

18–24 questions is mentally draining. The author:

> The fatigue from being questioned is real, but it's far smaller than the fatigue of re-doing implementations downstream.

Trade-off call: short-term questioning fatigue vs medium-term implementation-redo fatigue — grill-me picks the former.

ryonakae's recommendation:

- Model: Claude Opus 4.6 or Sonnet
- Effort: medium

Why: crafting good questions requires reasoning, but too-high effort makes questions overly cautious and stall. Medium is the "deliberate but not paralyzed" balance.

Top-tier (Opus 4.8): deeper questions, higher cost. Valuable for genuine production-level design decisions.

Small models (Haiku 4.5 / Qwen 3.6): question quality drops, grill-me's payoff diminishes — not recommended.

Anthropic Claude Skills philosophy:

- Thin text wrappers reshape agent behavior
- No coding required — one Markdown file, done
- Composable — multiple Skills can apply at once
- Shareable — distributed via GitHub / Gist / a registry

grill-me is one example of Claude Skills in practice, others include:
- "summarize-file" — file-summarization focus
- "refactor-only" — allow refactoring only
- "test-first" — write tests first
- "explain-then-code" — explain, then code

Ecosystem: Command Code's Design Partnership Mode (17+ variants) shares this philosophy — switch the agent's personality at will.

Late-2026 AI-agent design currents:

grill-me sits at the highest HITL end — the peak of the "AI can't run alone; it must stay aligned with the human" family. Full-autonomy tools (Devin / Cowork) point at "delegate"; grill-me points at "design together."

(1) New-feature design phase: unclear product direction, multiple options open

(2) Legacy integration: many existing-system constraints — dangerous for an AI to run alone

(3) Teaching: junior developer + AI dialog builds design knowledge

(4) As team meeting minutes: capture design decisions as Q&A

(5) Tasks with heavy dependencies: can't just implement — many premises must be aligned first

(1) Simple bug fixes: questioning is overkill; implement directly

(2) Bulk repetitive tasks: applying the same change to 100 files — nothing to grill about

(3) Exploratory prototyping: you don't know what you want, can't answer the questions

(4) Time-critical incident response: need action, not questions

(5) Personal experimentation: phases like Command Code's taste-1 learning — "try things to learn taste" — don't fit

(1) Skill activation isn't always reliable: even with grill-me enabled, some models still jump straight to code — choice of model and effort matters.

(2) Question quality varies: question depth tracks LLM understanding — Qwen 3.6 or Kimi may deliver a weaker experience.

(3) Team rollout: easy to opt in personally; mandating it team-wide will split preferences — voluntary adoption is realistic.

(4) Option quality: sometimes an obviously-inferior option sits inside the 2–5 choices — evaluate critically instead of blindly picking.

(5) Managing question fatigue: 18–24 questions can wear you down — plan breaks into the session.

Solo developers: enable grill-me in Claude Code or Cursor with Opus 4.6 / Sonnet at medium effort; start with new-feature design.

Teams: adopt as a shared skill for design review; anchor design decisions in a grill-me session pre-implementation. Store session logs in Confluence / Notion as substitute design docs.

AI-workflow designers: use grill-me as a model — build your own Skills with domain-specific question patterns (finance → compliance, medical → safety, etc.).

Matt Pocock's grill-me is a masterpiece of Agent Skill design. Three lines fundamentally reshape AI-coding-agent behavior. Replacing plan mode's "plan → build → re-plan" with "grill → complete understanding → frictionless build" slots into the "HITL assistant, not full autonomy" family alongside Crit.md and Command Code's Design Partnership Mode. It's the counterweight to Claude Cowork and ChatGPT Work's full-autonomy path — sketching a future where you design together with the AI. Applied in the right situations (new design / legacy integration / education / heavy dependencies) and skipped in the wrong ones (bug fixes / bulk / prototyping / incidents), it earns its place with Opus 4.6 / Sonnet at medium effort.

Related services from us — software development, AI consulting, Hermes Agent setup, and OpenClaw setup. For enterprise Agent Skill adoption, building HITL workflows around grill-me, or custom team Skill development, get in touch.

- Zenn article (ryonakae) — grill-me skill writeup
- Matt Pocock (originator)
- Anthropic Claude Code
- Related columns: Crit.md (HITL review substrate), Command Code (taste-1 personalization), Claude Cowork Web/Mobile, OpenAI ChatGPT Work, Cursor iOS support, Herdr (agent multiplexer), Hunk (diff viewer)