📖 Living glossary (read first — come back whenever you need to)
These are the NEW terms in this module. The core vocabulary (model, prompt, agent, skill, codebase, harness) was defined in Track 1 — here we just use it.
🔥 The grill-me skill (text)
🧠 Imagine it this way: before building a house, a good architect doesn’t say “okay, I’ll get started.” They asks too many questions: how many bedrooms? Morning or afternoon sun? Budget? Each answer prevents a wall from going in the wrong place. Grill-me turns the AI into that fussy architect—and that’s why it works.
A grill-me is, in Matt Pocock’s words, "unreasonably effective" (effective to a point that seems unfair) — and the secret is that it tiny: fits in 4-5 sentences. It doesn’t teach the AI to code; it only changes the stance Instead of AI taking your vague request and coding based on assumptions, it becomes an interviewer adversarial that asks questions, raises ideas you hadn’t considered, and solves the design tree dependencies one at a time.
The detail that makes the skill shine is in the final instructions: one question at a time (not a 20-item questionnaire that paralyzes you), with the recommended answer already included (you only confirm or correct—much faster) and if the question can be answered by looking at the codebase, the AI looks at the codebase instead of asking you. This last point is what separates grill-me from a chatty chatbot: it only spends the your time on what really requires your mind. Below is the REAL skill text (frame 31 of the video)—copy and paste:
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer. Ask the questions one at a time. If a question can be answered by exploring the codebase, explore the codebase instead.
The skill flips the script: the AI questions you instead of guessing. The result is shared understanding.
⚠️ Common beginner mistake
Think that "good skill" = "big skill." grill-me is powerful because is short. If you inflate it with 30 rules, it becomes noise, uses up context window, and loses focus. Resist the urge to “improve” it by making it longer.
In one sentence: grill-me is 5 sentences that turn the AI into an adversarial interviewer—one question at a time, with a guess included.
Going deeper (optional): why does "one question at a time" change everything?
When AI dumps 15 questions at once, you answer on autopilot and the important decisions get lost in the middle. One question at a time forces focus: every answer you give updates the context and refines the next question. It’s a dialogue, not a form. Add “give your recommended answer” and you go from writing answers to reviewing them—much less effort per decision.
🔟 The 10-decisions prompt
🧠 Imagine it this way: you’re going on a road trip across the country. There are a thousand decisions (which gas station, which snack), but only about 10 can change the whole trip: route, car, dates, who’s going with you. Picking the wrong diner costs 5 minutes; taking the wrong route costs the day. David's prompt makes AI list the "routes" before letting you hit the road.
While grill-me is a saved skill, the favorite prompt of David Ondrej is an instruction it pastes directly. The structure has three moves in a single sentence: (1) "describe my vision" — makes the AI tell you, in its own words, what it understood you want (so you can catch misunderstandings early); (2) "list the 10 most consequential decisions" — of software design / architecture and of product — that will shape the project; and (3) "interview me until you understand 98%".
The number "10" isn't magic — it's a attention budget. It forces the AI to prioritize: separate the choices that shape everything (a consequential decision, such as “monolith or microservices,” “which database,” “custom or third-party auth”), from reversible and inexpensive ones (the color of a button). Without this ceiling, the AI either lists 3 obvious things or dumps 50 trivial items. Asking for exactly the 10 most consequential ones is what makes for a conversation worth your time. Copy the prompt:
Describe my vision for this project in your own words. Then list the 10 most consequential decisions—about software design/architecture and product—that will shape this project. Then interview me, one question at a time, until you understand my vision at 98%. For each question, give your recommended answer. If something can be answered by exploring the codebase, explore the codebase instead of asking me.
In one sentence: "describe the vision → list the 10 most consequential decisions → interview me until 98%" makes the AI prioritize before coding.
🎯 "Interview me until 98%"
🧠 Imagine it this way: "I understand 100%" doesn't exist—there's always a detail that only shows up while coding. But "I understand 60%" is a recipe for rework. 98% is the sweet spot: aligned enough to get started, without turning it into an endless meeting in pursuit of perfection.
The “98%” is a stop number clever. It solves the opposite problem of a loose grill-me: without a target, the interview either ends too soon (the AI thinks it understands and disappears around 50%) or never ends (asking trivial details until the end of the world). By asking for "up to 98%", you tell the AI: keep questioning me as long as consequential decisions remain open; stop when only details that can be resolved during implementation remain. It’s the practical translation of the shared understanding by Pocock.
Why not 100%? Because the last 2% only show up when you’re working with the code—trying to nail them down in the interview is a waste. And why is this prior alignment so valuable? Because it’s here, in the cheap conversation, where you "work out the weirdness before implementing" (flush out weirdness before we implement, in Pocock’s words). A misunderstanding caught in the interview costs one sentence; the same misunderstanding caught after 2 hours of coding costs those 2 hours—plus your patience. Common mistake: treating the interview as a formality and answering "whatever" to everything — then the 98% is false, and the rework comes back.
🔬 Worked example: grill-me on a “notes app”
You paste the prompt for the 10 decisions with the vision "I want an app where I can jot down ideas." The AI describes your vision and starts the interview, one question at a time, with a suggestion included:
AI · question 1 (decision: audience)
"Is it just for you or multi-user? I recommend: only you in v1 — cut auth and synchronization now." → You: “just me.”
AI · question 2 (decision: persistence)
"Notes in the browser (localStorage) or in a file on disk?" I recommend: .md files in a folder—portable and versionable." → You: “.md files, yes.”
AI · question 3 (decision: search)
"Is text search enough, or do you want tags?" I recommend: text in v1, tags later." → You: “text is enough.”
In 3 questions, three consequential decisions were locked in— before a line of code. The AI gets to 98% and only then proposes the plan. Without grill-me, it would have guessed “multi-user + Postgres database + auth,” and you’d discover the overkill only during review.
Quick recall: why does the prompt ask for "98%" and not "100%"?
In one sentence: 98% means “aligned enough to start” — the final 2% gets worked out hands-on in the code.
⏱️ When to use
🧠 Imagine it this way: you don’t call the architect to change a light bulb. But to build a house? Always. Grill-me is the architect: use it when the task is new, ambiguous, or easy to get wrong — not for a one-line change.
Pocock positions grill-me as replacement for the plan mode: instead of the agent spitting out a plan for you to approve blindly, it interviews you first. Its phrase sums up the trigger: "here's my idea, interview me, let's reach shared understanding, flush out weirdness before we implement." In other words: always use it whenever there’s a ambiguous idea to resolve before execution.
In practice, it’s worth it when: the feature is new (there’s no established pattern in the codebase), there’s architecture or product decisions in play, the cost of getting it wrong is high (redoing it hurts), or you feel that your own idea is still nebula. It doesn’t apply to small, obvious tasks (“rename this variable,” “fix this typo”)—there, the interview just adds friction. Common mistake: using grill-me on everything, including trivial things, and getting annoyed with the AI for “asking too many questions” — the problem isn’t the skill, it’s the wrong context for using it.
✓ Use grill-me when…
- • New feature, with no pattern in the codebase.
- • Architecture/product decisions are at stake.
- • The cost of getting it wrong is high (redoing it hurts).
- • Your own idea is still unclear.
✗ Skip grill-me when…
- • It’s a typo, rename, or one-line tweak.
- • There’s already a clear pattern to follow.
- • The task is mechanical and reversible.
- • You just want a quick draft to throw away.
In one sentence: use grill-me as a substitute for plan mode for anything new, ambiguous, or costly to get wrong—not for trivial tasks.
🛠️ Adapt it to your project
🧠 Imagine it this way: the grill-me is a base cake recipe. It works as is, but gets better when you adjust it to your oven: change the number of decisions, the project focus, the tone. The structure stays; you calibrate the ingredients.
Pocock insists that skills are for adapt, not worship it. grill-me and the 10-decisions prompt are starting points; the real gains come from calibrating them to your your context. Three levers: (1) the number — "10 decisions" might be 5 for a bug fix or 15 for a greenfield product; (2) the focus — ask that decisions prioritize what matters to you (performance? accessibility? infrastructure cost?); (3) the codebase trigger — in an existing project, reinforce “explore the codebase before asking me” so it doesn't interrogate you about things already decided in the code.
Another powerful adaptation: save the grill-me as a named skill (e.g.: /grill-me) to invoke with a command, and keep the 10 decisions versioned as a snippet that you paste in when the project is large. And the point that connects to the next lesson: grill-me rarely works alone — it’s the first link a pipeline (grill-me → PRD → issues) that you’ll see in module 5.3. Common mistake: copy the English text and never translate or adapt it to your domain — the skill works much better when it speaks your project's language.
--- name: grill-me description: Entrevista adversarial antes de implementar. --- Descreva a minha visão com as suas palavras. Liste as N decisões mais consequentes (arquitetura + produto), priorizando CUSTO e SIMPLICIDADE. Me entreviste uma pergunta por vez até 98% de entendimento, sempre com a sua resposta recomendada. Se a resposta estiver no codebase, explore o codebase em vez de perguntar. (N = 5 pra bug fix, 10 padrão, 15 pra projeto novo.)
In one sentence: keep the structure (describe → list → interview up to 98%) and calibrate the number, focus, and codebase trigger to your project.
🚧 Common mistakes
🧠 Imagine it this way: The world’s best architect is no help if you answer “whatever” to every question. grill-me only works if you play along—it amplifies your clarity; it doesn’t replace it.
The grill-me fails in a few predictable ways. The first is inflate the skill: you "improve" the text by stuffing it with rules, it loses focus and the effect disappears. The second is answer automatically ("whatever", "could be") — then the 98% is false and the rework you wanted to avoid comes back. The third is skip the codebase trigger: without “explore the codebase instead of asking me,” the AI grills you about things that are already decided in the code, and you get tired for no reason.
The fourth is use in the wrong context (interviewing over a typo) — pure friction. And the fifth, more subtle: blindly accept the AI’s guess. The “recommended answers” are a great shortcut, but you own the product (remember Track 2) — if its guess goes against your vision, the point is to fix, not confirm. grill-me gives you a copilot that asks questions; you’re still the pilot. Use the checklist below before each interview:
The five pitfalls along the way. Avoid them all and you’ll reach a real 98%.
Antes de rodar a grill-me, cheque: [ ] A skill está CURTA (4-5 frases)? Não inchei de regras? [ ] A tarefa é nova/ambígua/cara de errar? (Se trivial, pule.) [ ] Incluí "uma pergunta por vez" + "dê sua resposta recomendada"? [ ] Incluí "explore o codebase em vez de me perguntar"? [ ] Vou responder DE VERDADE (nada de "tanto faz")? [ ] Lembro que o palpite da IA é sugestão — eu decido o produto?
Quick recall: which of these is NOT a misuse of grill-me?
In one sentence: the grill-me amplifies your clarity — it fails when you bloat the skill, answer on autopilot, or give up making decisions.
🧾 Module Summary
Next module:
5.3 — grill-me → PRD → issues Pipeline: chain the interview into a flow from brain to backlog.