Foreword

I wonder if you've ever been in this situation: you have a vague idea in your head, you open an AI coding assistant, you hammer out a bunch of output, and then code is generated, but it's completely not what you wanted. You revise it round after round, and finally you realize: the problem isn't the code; you didn't figure out what you wanted in the first place.

Matt Pocock calls this Misalignment, the single most common failure mode of AI Agent programming.

Matt is one of the most influential educators in the TypeScript world, founder of Total TypeScript, with a newsletter of nearly 60,000 subscribers. He open-sourced a set of AI programming Agent skills called mattpocock/skills, which has already garnered 176k stars on GitHub. The core philosophy is: the biggest bottleneck in AI programming is not code generation capability, but a lack of engineering discipline.

The one most worth talking about first is grill-me.

What is grill-me

grill-me, literally translated as "interrogate me." Its SKILL.md is written like this:

A relentless interview to sharpen a plan or design.

What it does is simple: before you start writing code, the AI launches a "relentless interrogation" at you, asking you one by one to clarify that vague idea in your head. It's not the AI thinking for you, but the AI asking you. You are the decision-maker, and the AI is the product manager who doesn't let any detail slip.

It calls another skill under the hood, grilling, with four core rules:

1. Ask one at a time, don't bombard. One question at a time, wait for your answer before continuing.
2. Each question comes with a recommended answer. Not a dry "What database do you want to use?" but "Based on your scenario, I suggest PostgreSQL, what do you think?" You just need to say yes or no.
3. Don't ask me what you can look up yourself. Facts that can be found in the file system or codebase, the AI looks up itself. It only asks you the decision questions that only you can answer.
4. Don't act until we reach a consensus. Not a single line of code is written before a "shared understanding" is reached.

Attached is the original text of grilling:

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.

Translated, it means: Walk down each branch of the decision tree and ask me one by one, each question with your recommended answer. Ask one at a time, wait for my answer. Don't ask me about facts you can look up yourself, but the decision-making power is mine. Don't act until we reach a consensus.

When to use it

Any time you're ready to have AI write code, but the requirements are still at the "I roughly want..." stage.

For example, these scenarios:

• A new feature has only a one-sentence description, and the details are all guesswork
• You want to refactor a piece of code, but you're not sure where to stop
• Several technical approaches each have pros and cons, and you don't know which to choose
• You receive a requirements document, and after reading it you find fuzzy areas everywhere
• You want to do a side project, but you haven't figured out what features to include in the first version

Conversely, if the requirements are already very clear, you don't need to use grill-me; just let the AI get to work.

An example

Suppose you say: "I want to add a save function to the card."

Without grill-me, the AI might start writing code directly. With grill-me, it will ask you back:

Q1: Which "card" are you referring to? I see two types in the code: NoteCard and TaskCard. I suggest supporting saving for both, what do you think?

You say: "Just NoteCard."

Q2: Save to where? The current project uses localStorage. I suggest keeping it consistent and saving locally. However, if there's a need for multi-device sync later, you could also connect directly to a backend API. Which do you prefer?

You say: "Save locally for now."

Q3: How should saving be triggered? I suggest adding a bookmark icon in the top right corner of the card, clicking to toggle save/unsave. Or do you want a different interaction?

You say: "An icon is fine."

Q4: Do saved cards need a special marker? For example, a grayed-out badge, or displayed in a separate "Saved" list. I suggest just doing the icon state toggle (filled/outlined) for now, without a separate list.

You say: "Okay, just filled/outlined toggle."

Q5: Do we need to persist the list of saved card IDs? I suggest using a savedNoteIds: string[] stored in localStorage, with the key app:saved-notes.

You say: "Okay."

Consensus reached: Add a bookmark icon to the top right corner of NoteCard, click to toggle save state, saved icon becomes filled, state stored in the savedNoteIds array in localStorage. Does not involve TaskCard, no separate list. Confirm?

See, after five rounds of dialogue, that "add a save function to the card" in your head has become a small requirement with clear boundaries, ready to be implemented. This is the value of grill-me — it doesn't think for you, but it forces you to turn a vague idea into concrete decisions.

A real feeling

In actual use, you'll find an interesting phenomenon: for most questions, you actually directly adopt the AI's recommended answer, and only a few you change based on your own ideas. The whole process looks like the AI is making decisions, and you're just "approving."

But that's precisely where the value lies.

You're not passively accepting the AI's plan; rather, in the process of the AI proposing the plan, you gradually see the full picture of the entire requirement. Each question helps you fill in a detail you hadn't thought of, and each recommended answer helps you verify "is this approach reasonable?"

After a few rounds, you already have a clear idea in your mind about how this requirement should be implemented, what the boundaries are, and what to watch out for.

In other words, the real value of grill-me is not "the AI made the decision for you," but "through the AI's questioning, you yourself thought through this requirement thoroughly."

Even if you chose all of the AI's recommendations, after going through this round, your depth of understanding of the requirement is completely different.

How to use it

There are two ways to install, depending on your style:

Method 1: skills.sh CLI (editable version)

Copy the skills into your project, you can modify them freely:

npx skills.sh install mattpocock/skills

Then run /setup-matt-pocock-skills once in the project to complete initialization.

Method 2: Claude Code Plugin (maintenance-free version)

# In Claude Code
/plugin marketplace add mattpocock/skills
/plugin install mattpocock-skills@mattpocock

# Or in the terminal
claude plugin marketplace add mattpocock/skills
claude plugin install mattpocock-skills@mattpocock

After installation, type /grill-me to trigger it.

Note, grill-me is a User-invoked type — the AI will not trigger it automatically; it only starts when you actively input it. This is a deliberate design: Matt divides skills into two categories, User-invoked is orchestration (the human decides "when to do what"), and Model-invoked is execution discipline (the AI decides "how to do it"). The principle is: Humans are responsible for orchestration, Agents are responsible for execution.

Experience after starting: You state your idea → AI asks questions one by one (with recommended answers) → resolves along the decision tree step by step → reaches consensus → can use /to-spec to convert the consensus into a structured spec.

grill-me's position in the entire pipeline

grill-me is not isolated; it is the entry point of a complete workflow pipeline designed by Matt:

/grill-me → /to-spec → /to-tickets → /implement → /code-review
 [Alignment]     [Issue Tracker]  [Blocking Tickets]  [Internal /tdd]  [Dual-Axis Review]

Alignment (grill-me) → Specification (to-spec turns consensus into a structured spec, published to the Issue tracker) → Decomposition (to-tickets breaks it down into tracer-bullet vertical slices, each ticket completely runs through from schema to API to UI to testing) → Build (implement drives TDD red-green-refactor) → Review (code-review launches two parallel sub-Agents, one checks Standards, one checks Spec fidelity, reporting independently without merging).

Without alignment, all subsequent steps are built on an unstable foundation.

Final words

After installation, just use /grill-me first; don't run the entire pipeline right from the start. Next time you have a vague idea, before letting AI write code, do /grill-me first. You'll find that after being grilled, your understanding of what you want to do is much clearer — many times you think you've figured it out, but you actually haven't.

Once you're familiar with it, gradually introduce the subsequent skills and find the combination that suits you.