Start using /grill-me: get 10x better results with AI

Five instructions.

That was the skill I kept seeing people talk about.

Matt Pocock opened the GitHub repository on February 3, 2026.

By Aug 5, it had 204k stars.

Skills.sh listed 49 skills and 13.3M total installs. grill-me sat at the top with 751.6K.

But what made this 5 lines of instruction go viral?

I had been using it for my own work and seen magic happened. So I started taking Matt’s skills apart.

I wanted to know what each sentence controlled: where human decisions ended, what got written down, and what allowed the next skill to begin.

The length got my attention. The professional judgment underneath kept me there.

AI can perform more of the work. Your domain expertise determines whether it performs the right work.

Matt’s skills show one way to encode that expertise.

What’s inside:

• What grill-me took back from AI

• Why grill-me is so useful in any field

• What happens after decisions are settled

• What deep modules explain about AI work

• What changed inside my own skills

• What Matt skills you can use for daily AI work

• The prompt and professional terms I kept

• Turn one repeated correction into a skill

What `grill-me` Took Back From AI

This is the complete body of the original skill, separated into its five instructions:

1. Interview me relentlessly about every aspect of this plan until we reach a shared understanding.

2. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one.

3. For each question, provide your recommended answer.

4. Ask the questions one at a time.

5. If a question can be answered by exploring the codebase, explore the codebase instead.

Annotated GitHub screenshot of the complete original grill-me skill body, containing the five instructions analyzed in the article.

The order of actions make a big difference.

Most of us have experienced the opposite process:

You describe an idea
        ↓
AI fills in the missing decisions
        ↓
AI starts making things
        ↓
You correct the assumptions after the work exists

The five instructions change the order:

You describe an idea
        ↓
AI finds the decision tree
        ↓
AI asks one question and recommends an answer
        ↓
You decide
        ↓
AI follows the next dependency

The first instruction gives the interview its depth.

Relentlessly does more work than a paragraph asking the AI to be thoughtful. It pushes the agent to continue until both sides can state the same plan.

The second instruction gives the interview an order.

A decision tree means one answer can create, remove, or change the questions below it. If you have not decided who the course is for, asking about the checkout page is too early.

The third instruction makes the AI do legwork.

A question alone hands the thinking back to you. A recommended answer forces the agent to look at what it knows, take a position, and still leave the decision with you.

The fourth instruction protects the feedback loop.

When AI asks eight questions together, your first answer may make the other seven irrelevant. One question at a time allows each answer to change what comes next.

The fifth instruction separates facts from decisions.

If the answer exists in the codebase, the AI should find it. Your attention belongs on the choice that cannot be retrieved from a file.

That is what grill-me took back from AI:

The moment when missing information quietly turns into an AI-made decision.

The current grill-me is a one-line front door to a grilling session.

grilling keeps dependency order, recommendations, and one-question pacing. It also expands the search from the codebase to the wider environment.

Facts stay separate from human decisions. After every question, the skill waits. It does not act until the human confirms that both sides share the same understanding.

The wording grew more precise. The central control stayed intact.

The AI must understand your decisions before it acts on them.

Share

Why `grill-me` Is So Useful in Any Field

That control travels because every field has choices that determine what comes next:

• In writing, settle the reader, argument, and evidence before drafting.

• In teaching, settle the learner, outcome, and progression before producing lessons.

• In research, separate facts the agent should retrieve from conclusions only you can judge.

• In product work, resolve the user, scope, and tradeoffs before implementation.

grill-me reached 751.6K installs.

Matt’s five-skills guide gives the method a useful scale. One course-editor feature took 16 questions. He says more complex sessions can reach 30, 40, or 50.

“One question at a time” can sound slow when you first read it. It does move more work into the decision stage.

I was integrating a contextual linking strategy into my SEO skills. Starting with /grill-me dug out the thinking I had only vaguely considered and never properly weighed.

One decision at a time revealed the thoughts I vaguely consider but never went through seriously

Those decisions have to be made somewhere. When they are skipped at the beginning, they return later as rewrites, abandoned branches, and arguments with work that already exists.

That is why the skill transfers. It moves judgment to the point where changing direction is still cheap.

Once those decisions are settled, they still need somewhere to go.

As I went through several of those questions, I started to see the pattern and wanted more, faster. So I switched to the companion /batch-grill-me skill.

Batch grill me is especially useful when you find one-at-a-time becomes too slow and want to view the complete picture first

Share

What Happens After the Decisions Are Settled

A conversation contains early guesses, corrected answers, rejected branches, facts the AI found, and decisions the human made. A later agent can read all of it and still choose the wrong sentence as the current truth.

This is where to-spec begins.

Its job is simple: “This skill takes the current conversation context and codebase understanding and produces a spec.”

to-spec synthesizes what has already been settled: the user’s problem, desired result, user stories, implementation and testing decisions, out-of-scope boundaries, and further notes.

to-spec leaves out details that will age quickly. Exact file paths and working code snippets usually change faster than the decisions they record.

A small prototype can stay when it preserves the decision more precisely than prose. This is the volatility boundary: durable decisions stay, while fast-changing implementation details stay out.

The agent still has one bounded question to settle. It explores the repository, identifies the highest useful test seams, and asks the human to confirm them.

That does not reopen the product decision. It confirms where the promised behavior will be visible later.

For example, imagine that the settled requirement is: a paid member can download a course worksheet after checkout.

The conversation may contain dozens of details. The specification preserves the durable ones:

• who the member is;

• what successful access means;

• which states must be handled;

• what remains outside the work;

• where a test can observe the result.

When the issue is published and labeled ready-for-agent, the next stage can begin without asking the human to reconstruct the whole conversation.

One good example I particularly love: as I settled my decisions on the video generation pipeline, /to-spec turned them into one durable spec. That single spec fanned out into the 13 tickets the work actually needed.

/to-spec generated video pipeline spec on my GitHub repo and created 13 independent issues with bounded tasks

That handoff with spec is the point where conversational understanding becomes durable state.

Share

What Deep Modules Explain About AI Work

A large amount of AI work can involve vibe coding. That makes software faster to produce. It also makes structural decisions easier to multiply before you have named them.

One of Matt’s most useful coding skills gave me the professional term for a pattern I had been trying to describe: a deep module.

A deep module places a large amount of useful behavior behind a small, stable interface. A shallow module exposes a large interface while hiding very little.

Depth is a property of the interface: how much behavior the caller receives compared with how much implementation the caller must understand. It does not mean “put everything in one giant file.”

This matters when you work with AI because every public method, helper, adapter, and cross-file convention becomes another thing the agent has to hold in context.

A deep module gives the agent a clean seam. The caller knows what goes in, what comes out, and what failure looks like. The implementation can change behind that test surface without forcing every caller to change with it.

Matt’s tdd skill follows the same order:
First, agree on the public seam.
Second, derive the expected result from an independent source.
Third, test one complete behavior.
Watch it fail before making it pass.

A stronger vibe-coding request is:

Design this as a deep module with the smallest stable interface. Place the seam where the promised behavior can be tested from outside. Keep implementation choices local to the module.

The AI now has three design constraints: small interface, local complexity, observable behavior.

The deletion test makes the difference concrete. If removing the module forces many callers to recreate its behavior, the module had depth. If removing it means deleting a few pass-through calls, it was probably shallow.

Professional vocabulary names the design, but module shape affects AI too. A deep module gives the agent fewer public concepts to trace and a clearer place to change and test.

It cannot guarantee the right code will be found. It reduces the cross-file reasoning once the agent reaches it.

Share

What Changed Inside My Own Skills

After I applied these skills, the change I appreciate most is simple. I can pick up a half-done job from anywhere, see the state of the work at a glance, finish with far less iteration, and end up with a much cleaner setup.

I applied the same principles to my article system.

Now I can open a new AI chat session from anywhere and pick up right where the work stands, because the state travels with the work instead of living in one chat.

I started a new chat session with Claude to pick up writing, because I’m nearly hitting the usage limit with ChatGPT, and I needed that to finish my remaining tasks there.

My video lifecycle got a lot shorter too.

On a laptop without the improved skills, six versions got rejected and none of them satisfied me. With the skills, one round is already good enough for what I need right now.

Without the improved skill, I had to go through 7 rounds while still not getting the right video. With the skill, I often get the result with just one pass

The comparison was observational across different machines and projects. But it showed me what changed when my accumulated decisions traveled with the work.

My preferences are now captured inside the workflows and the first pass can already reflect how I think.

This is where AI can perform more of the work. But your choices determines whether it performs the right one.