Starting projects with the /grill-me skill

Starting a new project with an AI agent often fails in the same way: you describe a vague idea, the agent agrees with everything, and you end up building the wrong thing quickly. The /grill-me skill by Matt Pocock flips that dynamic. Instead of a yes-man, you get an interviewer that keeps asking until you and the agent share the same plan.

This post is a practical walkthrough: what the skill is, a basic workflow I use when starting something new, and a couple of short examples.

What /grill-me does

The skill itself is short. That is part of why it works. In essence it tells the agent to:

1. Interview you relentlessly about a plan or design.
2. Walk each branch of the decision tree one decision at a time.
3. Prefer reading the codebase over asking questions it can answer itself.
4. Recommend an answer for every question, so you can often reply with “yes” or a small correction.

You invoke it. The agent does not reach for it on its own. That keeps it intentional — you choose when you want pressure, not endless interrogation on every prompt.

A typical session is conversational and can run for a while. By the end you usually have clearer requirements, fewer hidden assumptions, and a summary of what you agreed on. That shared context is gold before you ask the agent to implement anything.

Why it shines at project kickoff

Greenfield work is where assumptions hide. You think you know the product boundary, the auth model, the data shape, and the first vertical slice — until someone asks a sharp question and the plan falls apart.

/grill-me is useful there because:

• It surfaces trade-offs early. Auth, multi-tenancy, billing, offline mode — the agent will walk into those branches if they matter.
• It turns vague goals into decisions. “Build an uptime monitor” becomes concrete choices: check frequency, alert channels, free tier limits, status pages, and so on.
• It reduces rework. Fifteen to forty-five minutes of grilling often saves hours of “wait, we should have done X instead.”
• It fills the agent’s context with your real preferences, not generic defaults.

I treat it as a pre-build stress test: idea → grill → build. If I need durable docs (ADRs, glossary), Matt’s ecosystem also has heavier siblings like grill-with-docs and domain-model. For many kickoffs, plain /grill-me is enough to get moving with confidence.

Install and invoke

From your project (or globally, depending on how you manage skills):

npx skills add mattpocock/skills --skill=grill-me

Then in Cursor (or another skill-aware agent), start a session with something like:

/grill-me I want to build a small uptime monitoring SaaS for indie hackers.

Or attach a short plan / sketch and ask it to grill you on that document.

A basic workflow

Here is the loop I use when starting a new project:

1. Write a one-paragraph pitch. Product, audience, and the smallest useful version. Keep it rough on purpose.
2. Run /grill-me on that pitch. Let the agent ask one question at a time. Accept recommendations when they are good; push back when they are not.
3. Stay on one branch until it is resolved. Do not jump around. If auth depends on tenancy, settle tenancy first.
4. Ask for a short summary when the tree feels closed. Capture goals, non-goals, key decisions, and open risks.
5. Only then implement. Hand the summary (or a PRD derived from it) to a coding session. Optionally follow with to-prd / issue breakdown skills if you use Matt’s fuller pipeline.

That is it. No ceremony beyond “talk until the plan stops wobbling.”

Example 1: kicking off a product

Imagine you start with:

I want to build SpaceUptime — monitoring for websites and APIs with a mission-control UI, free tier of 10 monitors, checks every 30 seconds.

A /grill-me session might walk through questions like:

Q: Who is the primary customer for v1 — solo founders, agencies, or enterprise SRE teams?
Recommended: Solo founders and small teams. Keep pricing and UX simple; delay SSO and audit logs.
You: Yes.

Q: What is the hard promise for check frequency on the free tier?
Recommended: 30s only on paid; free tier at 1–5 minutes to protect cost.
You: Free at 60s, paid down to 30s.

Q: Do status pages ship in v1?
Recommended: Yes as a thin public page for selected monitors — strong viral loop, small scope.
You: Yes, but no custom branding in v1.

Q: Where do alerts go first?
Recommended: Email + webhook. Add Slack/Discord after the core loop is solid.
You: Email only for MVP; webhook next.

After a stretch of this, you have a much sharper MVP: audience, pricing pressure, alert scope, and what is explicitly out of v1. That is the moment to open a coding agent and build the first vertical slice (create monitor → run check → show status → send email on failure).

Example 2: grilling a technical design

You can also grill architecture, not just product:

We’re adding host metrics (CPU/RAM/disk) via a Linux agent. Grill me on the design.

Expect branches like:

• push vs pull agent model
• auth for agent install tokens
• retention for time-series data
• how host monitors relate to HTTP monitors in the UI
• failure modes when the agent goes silent

Again, each question comes with a recommendation. You are not staring at a blank whiteboard — you are reacting to proposals, which is much faster.

If the agent can answer something from the repo (“how do we store monitor configs today?”), a good grill session sends it to the codebase instead of making you re-explain existing decisions. That keeps the interview focused on new choices.

Tips that make sessions better

• Start messy. A weak paragraph is enough. The skill exists to sharpen it.
• Say “yes” a lot when the recommendation is right. Momentum matters.
• Say “no, because…” when it is wrong. The correction is the value.
• Stop when decisions stabilize. You do not need to invent every edge case for year three.
• Save the summary. Paste it into the PR description, a CONTEXT.md, or your next agent prompt.
• Use it outside coding too. Course outlines, launch plans, hiring loops — same interview pattern works.

Looking ahead

AI coding tools are excellent at generating code. They are weaker at noticing the requirements you never stated. /grill-me is a small, sharp fix for that gap: make the agent argue with you before it writes a thousand lines.

If you are starting a project this week, try this once: write four sentences about what you want to build, run /grill-me, and only then ask for an implementation plan. The difference in clarity is usually obvious by the end of the first grilling session.

More from Matt on AI Hero: the grill-me write-up and the skill page. The source lives in mattpocock/skills.