Recently, the “grill me” skill has become extremely popular. After some comparison, many people have concluded that “grill me is more useful than superpowers,” and many have abandoned their previous workflows to switch to it.
However, grill me is a very unique, even somewhat eccentric skill. When you use it for the first time, you will definitely find its “relentless interrogation” quite jarring. Most skills aim to help you finish a task in one go. Grill me does the opposite; it won’t stop until every detail is clarified, and it’s not uncommon for it to ask 40 or 60 questions in a single session.
Why is such a strange skill being hailed as highly effective by so many?
In fact, it focuses on just one thing: making sure the AI truly understands what you want to achieve.
Our team has been using grill me for two months now, and today I want to talk about how to actually use this magical skill.
What is grill me
The original source for grill me can be found here: https://github.com/mattpocock/skills/blob/main/skills/productivity/grilling/SKILL.md
As a skill, its content is very short—only four paragraphs (it was even just two paragraphs in the early stages):
Interview me relentlessly about every aspect of this until we reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.
If a fact can be found by exploring the environment (filesystem, tools, etc.), look it up rather than asking me. The decisions, though, are mine — put each one to me and wait for my answer.
Do not act on it until I confirm we have reached a shared understanding.What kind of magic do these few short sentences hold?
Grill me solves “Intent Alignment”
Anyone with some experience in AI programming will generally agree: the more complex a project is, the more carefully you need to outline the plan during maintenance. Hoping that a one-sentence “wish” will lead the AI to produce exactly what you want is, in most cases, impossible.
The popular SDD (Spec-Driven Development) approach was largely created to solve this problem. Before making any changes, you first have the AI write a spec document. On one hand, this allows the AI to organize its own plan to avoid working blindly; on the other hand, it allows a human to review the AI’s plan. If there is a deviation from what you want, you can catch it and demand a rewrite immediately.
It sounds great in theory, but in practice, it often doesn’t work out that way.
I don’t know if you’re like me: once the AI generates a spec, I’m often too lazy to review it. At most, I give it a cursory glance before telling the AI to start working. Sometimes I don’t even look at it at all.
Initially, I thought I was just being lazy, but later I realized the root of the problem: when the AI produces a spec, I almost always feel it “looks fine” after reading it. Reading it feels like a waste of time.
Why does this happen?
Because AI is exceptionally good at producing “decent-looking garbage.” If you’ve ever used AI to write a paper or a performance report, you likely have a strong sense of this. The inherent nature of LLMs makes them great at synthesizing text that looks professional. However, in critical arguments, data, or citations, something is usually slightly off.
The same applies to AI-written design specs. It can spit out a structured, professionally worded implementation plan that makes you want to reply “looks good, go ahead,” but all the gray areas are glossed over:
- “Create a user-friendly X” — What does user-friendly mean here?
- “Add Y when necessary” — When is it considered necessary?
- “Refer to existing implementation” — Which implementation specifically?
You won’t notice these issues at the start; you usually only find them after the Agent has finished writing the code. It is precisely these misaligned intents that cause frustration and lead to endless rework.
So, is there a way to force the AI to align its intent with yours and truly understand what you want from the beginning?
Yes, that’s where grill me comes in.
Once you use grill me, you’ll find that it proactively aligns intent by asking questions from every possible angle. After rounds of dialogue, you will feel much more confident, knowing that the AI has considered everything comprehensively and that the subsequent implementation won’t deviate significantly.
Finding the uncertainties you didn’t realize existed
So, why is grill me so effective?
The core lies in this sentence within the skill:
Interview me relentlessly about every aspect of this until we reach a shared understanding.This sentence performs a crucial “role reversal.” Usually, we are the ones proactively writing prompts and directing the Agent. Now, the control is flipped, allowing the AI to ask us about uncertain issues.
In this way, we no longer need to “anticipate” what the AI might not understand. If the AI is confused, it will naturally ask us.
The principle behind this is unconscious uncertainty.
When using grill me, you might find that many questions are things you hadn’t even considered initially; they are unearthed through rounds of Q&A. Without these questions, the Agent would likely execute based on your flawed assumptions, leading to rework.
Claude engineer Thariq Shihipar wrote an article on “how to avoid losing control when using AI for complex tasks.” His core point was: don’t let the AI start working immediately; instead, let it help you identify the uncertainties you aren’t aware of.
As AI becomes increasingly powerful, the primary bottleneck has shifted from whether the AI can write the code to whether the human has explained the problem clearly. The “unknown blind spots” have become the biggest risk.
If we apply the familiar four quadrants of knowns and unknowns to AI programming, the “known” parts are easy:
- Known knowns: These are the prompts we write; the meaning is clear, and you know what you want.
- Known unknowns: Generally uncertain solutions that require research and discussion; these aren’t hard to clarify.
The truly difficult parts are the “unknowns”:
- Unknown knowns: Things you didn’t tell the AI because you assumed it would follow them, but sometimes the AI truly doesn’t understand.
- Unknown unknowns: These are the problems you suddenly discover through grill me that you hadn’t considered at all. A standard prompt would never uncover these.
Because they are unknown, they are blind spots. Either we don’t know that the AI doesn’t know (leading to intent deviation), or we don’t know what we don’t know (leading to a prompt that provides a wrong requirement or solution from the start).
The greatest value of grill me is in handling these “unknown” issues. It constantly probes vague areas, which is exactly where the biggest unknowns and uncertainties are hidden.
The questions might feel tedious, but discovering just one such blind spot makes the whole process worth it.
How to use grill me
Proactive Guidance
When using grill me, don’t just mindlessly answer “yes” or “no.” If you do, the answers lose their meaning, and you will quickly get bored, becoming a mindless “yes” machine.
Always remember: the true goal of grill me is to help you find unknown blind spots.
I throw points I think need discussion at it, letting it debate with me during the dialogue, intentionally guiding it toward the topics I need to discuss most.
My answering style varies greatly depending on the question:
- For issues I care about: I answer in detail, explain my reasoning, and throw back deeper questions for it to consider.
- For routine questions I expected: I just say “yes.”
- If it recommends a solution I disagree with: I say “no” and emphasize my logic.
- If I don’t understand its question: I tell it directly that I don’t understand and make it re-explain until I do (don’t be lazy here).
- If I find it obsessing over minor implementation details: I refuse to answer and tell it to stop asking about overly specific details.
Use a Lightweight Framework
Many people, after using grill me, firmly believe it is better than superpowers.
In reality, the styles of grill me and superpowers are poles apart. Superpowers is comprehensive, attempting to cover your entire development workflow. Grill me is minimalist; you need to use it flexibly according to your scenario. However, they both serve one purpose: avoiding “Vibe Coding” that produces garbage.
That said, the more experienced a developer is, the greater the boost from grill me.
This is because superpowers provides a “floor,” raising a 60-point performance to 80. Grill me raises the “ceiling,” taking you from 80 to 90.
As model capabilities continue to grow, Agents can reach a level of about 80 even without any skills. At this point, skills like superpowers that focus on the floor become less useful. This is why many people find that using superpowers with GPT-4o or newer models is sometimes less effective than not using it at all.
My personal experience is to use grill me paired with a lightweight SDD framework. Using grill me alone can feel a bit thin. Once the “grilling” is over, we can record the conclusions into a spec and then let the Agent implement it. I use a ultra-lightweight SDD framework I wrote called zest-dev, but you could also use something like OpenSpec. I wouldn’t recommend heavier SDD frameworks, though.