# Grill Me

> Stress-test a plan or design through a relentless, branch-by-branch interview until every load-bearing decision is resolved. Use when the user says "grill me", "interview me on this", "stress-test this plan", "find the holes", or wants someone to find the gaps before they commit. The point is to surface unanswered questions early so they get answered on a whiteboard, not in production.

- Skill: `xray-inc/grill-me` (Agent Skill)
- Install (CLI): `npx skillmds@latest add xray-inc/grill-me`
- Raw SKILL.md: https://api.skillmd.com/api/skills/xray-inc/grill-me/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: XRAY-INC (https://skillmd.com/u/xray-inc)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/xray-inc/grill-me

---


# Grill Me

Interview the user about every load-bearing decision in their plan or design until shared understanding is reached. The user wants the holes found — be useful by finding them.

## How to run

Ask one question at a time. Wait for the answer before the next question. Don't dump a list.

For each question, provide your **recommended answer** alongside the question — not as the final word, but as a Schelling point that makes "yes/no/different" cheap to answer. A bare question costs the user thinking time; a question + recommendation costs them a reaction.

If a question can be answered by reading the codebase, read the codebase instead of asking.

## Branches to walk

Walk these branches in order. Inside each branch, ask 3-5 probing questions before moving on. Skip a branch only if the plan genuinely has nothing in it (e.g., a refactor has no new users).

1. **Problem.** What's the actual problem? Who has it? How do you know? What's the cost of not solving it? What happens if we wait six months?
2. **Approach.** Why this approach over the obvious alternatives? What did you rule out and why? What's the simplest version that could work?
3. **Architecture.** Where does this live? What does it depend on? What depends on it? Where are the seams? What's the rollback?
4. **Scope.** What's in / out / explicitly deferred? What's the smallest shippable slice? What's the biggest thing that could expand scope mid-build?
5. **Risk.** What's the most likely way this breaks? What's the worst case? What signals would tell you it's going wrong before it does?
6. **Success.** How will you know it worked? What metric / behavior / outcome? When do you check?

## When to stop

Stop when:
- The user signals they're done, OR
- Every branch has been walked and recommended answers are committed, OR
- A blocking ambiguity has surfaced that needs offline resolution (name it, log it, stop).

Don't keep grinding past clarity. The point is to surface what was missing, not to fill the conversation.