grill-me
by mattpocockgrill-me turns an AI assistant into a structured reviewer for plans and designs, asking one question at a time, resolving decision branches, and using the codebase when possible to stress-test requirements.
This skill scores 66/100, which means it clears the bar for listing but as a limited, lightweight install. Directory users can quickly understand the core behavior—an aggressive, one-question-at-a-time design review with recommended answers—but the repository provides only a short instruction file, so adopters should expect to supply their own judgment about scope, stopping conditions, and fit.
- Very triggerable: the description clearly signals when to use it for stress-testing a plan or when the user explicitly says "grill me".
- Operationally simple: it tells the agent to ask questions one at a time and to provide a recommended answer for each question.
- Adds some agent leverage beyond a generic prompt by directing the agent to explore the codebase when answers can be derived there instead of asking the user.
- Thin repository evidence: only a single SKILL.md is present, with no examples, support files, or install guidance.
- Limited constraints and workflow detail: it does not define stopping criteria, depth limits, or how to handle ambiguous branches in the decision tree.
Overview of grill-me skill
What grill-me does
The grill-me skill turns an AI assistant into a structured reviewer for plans and designs. Instead of giving a broad opinion, grill-me asks one question at a time, walks through decision branches, and recommends an answer for each question. The real job-to-be-done is not “brainstorm with me,” but “force hidden assumptions into the open before I commit.”
Best fit for Requirements Planning
grill-me for Requirements Planning is a good fit when you have a feature idea, architecture change, migration plan, or delivery proposal that still has unresolved dependencies. It is especially useful for product managers, tech leads, founders, and engineers who need to turn a fuzzy plan into a decision-ready spec. If you want pressure-testing rather than reassurance, this skill is a strong match.
Why use grill-me instead of a normal prompt
A normal prompt often gives an answer too early. The grill-me skill is different because it stays in interrogation mode until the plan is clear, and it is explicitly told to inspect the codebase when a question can be answered from source instead of asking you. That makes it more practical for repo-backed planning than a generic “review my idea” prompt.
Important limits before you install
This is a very lightweight skill: the repo only exposes SKILL.md, with no extra rules, scripts, or references. That keeps grill-me install simple, but it also means output quality depends heavily on your initial context and your willingness to answer follow-up questions. If you want a polished framework with built-in templates, this is not that.
How to Use grill-me skill
Install context and where to read first
For grill-me install, add the skill through your usual skills workflow, then read SKILL.md first because that file contains nearly the entire behavior. There are no supporting resources to study, so adoption is mostly about understanding the interaction pattern: one-question-at-a-time, branch-by-branch, with codebase exploration when possible.
What input grill-me needs to work well
The best grill-me usage starts with a concrete planning object, not a vague topic. Give:
- the goal
- the current state
- constraints
- decision deadline
- success criteria
- known unknowns
A weak start: “Grill me on a new auth system.”
A stronger start: “Use grill-me on this requirements plan: migrate from session auth to OAuth for our B2B app in 6 weeks, keep SSO for enterprise customers, avoid downtime, and preserve existing admin impersonation. Biggest unknowns are tenant mapping, rollback, and support load.”
The stronger prompt gives the skill branches to inspect immediately.
Practical grill-me usage workflow
A reliable grill-me guide looks like this:
- Start with a short plan summary.
- Ask the assistant to use
grill-me. - Let it ask one question at a time.
- Answer crisply; avoid jumping ahead unless a dependency is blocking.
- If the project lives in a repo, tell the assistant to inspect relevant code before asking obvious implementation questions.
- After 10-20 questions, ask for a summary of resolved decisions, open risks, and next actions.
This works well for Requirements Planning because it converts an informal plan into a chain of explicit decisions.
Prompt pattern that improves output quality
Use a prompt that sets role, scope, and stopping condition:
“Apply grill-me to this plan. Ask one question at a time. For each question, give your recommended answer and explain the tradeoff briefly. If a question can be answered from the codebase, inspect the code instead of asking me. Stop after we have enough clarity to write implementation requirements.”
That prompt aligns closely with the skill and reduces generic chatter.
grill-me skill FAQ
Is grill-me good for beginners?
Yes, if the beginner already has a real plan to test. The grill-me skill is easy to invoke, but it can feel intense because it keeps drilling into assumptions. Beginners who want teaching or examples may prefer a more explanatory skill first, then use grill-me to validate the result.
When should I not use grill-me?
Skip grill-me when you need fast ideation, broad creative options, or a polished final document on the first turn. It is also a weak fit when there is no actual plan yet. If your input is just “help me think of something,” the interrogation style can feel premature.
How is grill-me different from just saying “challenge my plan”?
The difference is operational discipline. grill-me usage is built around sequential questioning and dependency resolution, not a one-shot critique. It also nudges the agent to inspect the codebase when evidence exists there. That usually produces fewer abstract objections and more grounded planning pressure.
Does grill-me work outside software projects?
Yes, but it is strongest for product, technical, and process planning where decisions branch and dependencies matter. For non-technical planning, you will need to provide more context manually because there is no codebase to inspect.
How to Improve grill-me skill
Give decision-grade inputs, not brainstorming fragments
To improve grill-me, feed it enough structure to interrogate. Include stakeholders, constraints, timeline, risks, and what is already decided. The biggest quality jump usually comes from naming tradeoffs explicitly, such as speed vs reliability, flexibility vs simplicity, or cost vs migration risk.
Watch for common failure modes
The main failure mode is shallow questioning caused by shallow input. Another is answering too broadly, which makes the conversation sprawl. A third is letting the assistant ask questions the repo could answer. When using grill-me for Requirements Planning, redirect it with: “Inspect the codebase for current behavior before asking implementation-surface questions.”
Iterate after the first pass
After an initial round, ask grill-me to switch from discovery to gap analysis. Good follow-ups include:
- “Which decisions are still under-specified?”
- “What assumptions look riskiest?”
- “What requirements are implied but unstated?”
- “Turn the resolved answers into a requirements checklist.”
This makes the skill more useful than a simple interrogation loop.
Adapt grill-me to the output you need
The best way to improve grill-me skill results is to define the artifact you want at the end: a spec outline, ADR inputs, delivery risks, or a go/no-go recommendation. The questioning style stays the same, but the end target changes what details matter. If you state the final artifact upfront, the questions become more selective and the session produces something easier to act on.