grill-me
by alirezarezvanigrill-me is a Decision Support skill that stress-tests plans and designs through one-question-at-a-time interrogation, recommended answers, codebase exploration, and helper scripts for extracting decision branches and tracking sessions.
This skill scores 78/100, making it a solid listing candidate for directory users who want an agent to interrogate plans or designs more systematically than a generic prompt. It has a clear activation pattern, memorable interaction discipline, and practical support files, though users should expect some setup ambiguity and heuristic tooling rather than a polished end-to-end package.
- Strong triggerability: the frontmatter explicitly says to use it when the user wants to stress-test a plan, get grilled on a design, or says “grill me.”
- Operational rules are concrete: one question per turn, provide a recommended answer, explore the codebase before asking, and walk the decision tree depth-first.
- Useful supporting materials include forcing-question patterns, stopping conditions, and Python scripts for extracting decision branches, generating questions, and tracking multi-turn sessions.
- No install command or README is present in the skill path, so users must infer installation from the broader repository or their Claude Skills setup.
- The companion tooling is heuristic and regex-based, and references a persona agent and slash command outside the shown skill directory, so adoption may require extra repo context.
Overview of grill-me skill
What grill-me does
grill-me is a decision-interrogation skill for Claude-style agent workflows. Instead of giving broad feedback on a plan, it interviews you one question at a time until the unclear branches, dependencies, trade-offs, and assumptions are resolved. The core behavior is simple but valuable: ask a forcing question, include a recommended answer, wait, then continue down the decision tree.
Best fit for Decision Support
Use grill-me for Decision Support when you have a product plan, engineering design, architecture proposal, migration strategy, launch checklist, or “we should do X” document that needs stress-testing before execution. It is especially useful when a plan contains TBDs, vague trade-offs, hidden dependencies, or decisions that were made by default rather than deliberately.
What makes this skill different
The differentiator is discipline. The grill-me skill does not bundle ten questions, drift into generic critique, or let the user answer vaguely. It prefers codebase exploration over unnecessary questions, walks branches depth-first, and asks forcing questions such as “Why X and not Y?” or “What would convince you this approach is wrong?” The repository also includes stdlib-only Python helpers for extracting decision branches, generating questions, and tracking multi-turn sessions.
When it is not the right tool
Do not install grill-me if you want a polished plan written for you from scratch, a lightweight brainstorming partner, or a fast “LGTM” review. It is intentionally uncomfortable: the skill is designed to slow the conversation down, expose weak reasoning, and force commitment. That makes it powerful before high-cost decisions, but excessive for trivial choices.
How to Use grill-me skill
grill-me install and repository path
Install with:
npx skills add alirezarezvani/claude-skills --skill grill-me
The skill lives under engineering/grill-me/skills/grill-me in the repository. Start by reading SKILL.md, then inspect the support files that explain how to run a better grill session: references/forcing_question_patterns.md, references/when_to_stop_grilling.md, and references/companion_tooling.md. The scripts are in scripts/ and require only Python stdlib.
Inputs the skill needs
For best grill-me usage, provide a plan or design artifact, not just a vague goal. Strong input includes:
- the decision you are trying to make
- the current proposed approach
- alternatives you considered
- known constraints, deadlines, and risks
- parts that are TBD or politically sensitive
- links or paths to relevant code, docs, tickets, or architecture notes
A weak prompt is: “Grill me on this idea.”
A stronger prompt is: “Use grill-me on docs/auth-migration.md. We plan to move sessions from Redis to Postgres before Q3. Focus on rollback, performance risk, and whether our dependency on the billing service is actually locked.”
Practical workflow
A high-signal grill-me guide workflow looks like this:
- Put the plan in a markdown file.
- Ask the agent to use
grill-meand read the plan first. - If the answer is in the repository or codebase, let the agent inspect files instead of asking you.
- Answer one question at a time.
- Capture decisions as they become locked.
- Stop only when the unresolved branches are exhausted.
For larger plans, run the helper scripts locally:
python scripts/decision_tree_extractor.py path/to/plan.md
python scripts/question_generator.py path/to/plan.md --output json
python scripts/grill_session_tracker.py --action start --session auth-migration --plan path/to/plan.md
These tools do not call an LLM. They help reveal decision branches and preserve state across long review sessions.
Prompt pattern that works well
Use a prompt that gives authority, scope, and stopping rules:
“Use the grill-me skill for Decision Support on this plan: <path>. Ask one question per turn. Provide your recommended answer with each question. Explore the codebase before asking anything answerable from files. Walk dependencies depth-first. Track resolved decisions and tell me when every branch is answered or when no new questions arise.”
This matters because the skill’s value comes from sequencing. If you ask for “all feedback at once,” you bypass the main benefit.
grill-me skill FAQ
Is grill-me only for engineering plans?
No. The repository path is engineering-oriented, and the codebase-exploration rule is useful for software projects, but the method works for product, operations, hiring, GTM, and strategy decisions too. The best fit is any plan where hidden assumptions are more dangerous than missing prose polish.
How is this better than an ordinary prompt?
A normal prompt like “critique this plan” usually produces a list of observations. grill-me creates an interrogation loop. Each question is tied to a decision branch, includes a recommended answer, and waits for your response before continuing. That makes it better for resolving ambiguity, not just identifying it.
Can beginners use grill-me?
Yes, but beginners should start with a short plan. The skill can feel intense because it asks for trade-offs, kill criteria, and alternatives. If you do not yet know the domain, answer honestly with what is unknown; the session can then separate “undecided” from “blocked by missing information.”
What should I check before installing?
Check that your agent runtime supports skills from GitHub and that you are comfortable with a multi-turn workflow. Also preview SKILL.md and the three reference files. If you want the helper scripts, confirm you can run local Python commands and that writing session JSON to ~/.grill_sessions/ is acceptable for your environment.
How to Improve grill-me skill
Give grill-me sharper source material
The fastest way to improve grill-me output is to make the plan more inspectable. Add headings for goals, non-goals, constraints, alternatives, dependencies, rollout, rollback, metrics, and open questions. The decision extractor looks for signals such as “we will,” “TBD,” “vs,” “depends on,” and “trade-off,” so explicit wording helps the workflow find branches.
Avoid common failure modes
Common failures include asking too many questions at once, accepting vague answers, skipping codebase exploration, or stopping after the first uncomfortable branch. If the agent bundles questions, correct it: “Return to grill-me: one question only, with a recommended answer.” If it asks something already documented, point it to the file and require it to inspect before continuing.
Iterate after the first session
After the first grill, revise the plan with locked decisions and newly discovered risks. Then run decision_tree_extractor.py again. This second pass often finds new branches introduced by your answers. A good session ends with fewer TBDs, clearer rejection reasons for alternatives, and explicit kill criteria for risky choices.
Tune the skill for your team
Teams can improve adoption by adding local examples: a good architecture decision record, a bad vague plan, preferred risk categories, and standard launch criteria. Keep the core grill-me discipline intact, but adapt the recommended-answer style to your organization’s constraints. The goal is not harsher questioning; it is faster shared understanding before expensive work begins.