agentleFS
abhaylaabhayla/claude-best-practices/.claude/skills/grill-me/SKILL.md

grill-me

Skill9 starsChanged 7 months agoMITView on GitHub

Audit a plan or design by interviewing the user relentlessly until shared understanding is reached, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

193 other projects use a version of this, 71 of them edited.

Adopted by

Most recently taken up by

Used with

Projects with it also use brief-to-tasks, writing-beats and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • julianoczkowskiSkill

    brief-to-tasks

    Break a design brief into an ordered checklist of independently buildable tasks using vertical slices. Saves as a markdown checklist. Use when user wants to break down work, create tasks from a brief, plan implementation order, or mentions "tasks" or "breakdown".

    Also in 7 projects that use this

  • LesaniSkill

    writing-beats

    Shape an article as a journey of beats, choose-your-own-adventure style. The user picks a starting beat from the raw material, you write only that beat, then offer options for where to pivot next, beat by beat, until the article reaches a natural end. Use when the user has raw material and wants to assemble it as a narrative rather than an argument.

    Also in 74 projects that use this

  • simo97Skill

    migrate-to-shoehorn

    Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial test data.

    Also in 78 projects that use this

  • simo97Skill

    request-refactor-plan

    Use this skill when user wants to create a refactor plan.

    Also in 45 projects that use this

  • LesaniSkill

    writing-shape

    Take a markdown file of raw material and shape it into an article through a conversational session — drafting candidate openings, growing the piece paragraph by paragraph, arguing about format (lists, tables, callouts, quotes) at each step. Use when the user has a pile of notes, fragments, or a rough draft and wants help turning it into something publishable.

    Also in 73 projects that use this

  • RoentekSkill

    loop-me

    Grill me about specs for the workflows I want to build, within this workspace.

    Also in 64 projects that use this

  • +1 more from simo97
  • +1 more from Lesani

The file

We split this skill into the rules it gives an agent

12 rules. 0 are common, 12 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 178 edited versions we read keep these.

  • 12

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Ask dependent questions one at a time.

    line 12
  2. Distinctive:

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

    line 14
  3. Distinctive:

    Before committing to a non-trivial architectural decision

    line 32
  4. Distinctive:

    When the user is uncertain whether their plan covers all the branches

    line 33
  5. Distinctive:

    Read whatever context the user shared — a plan file, a message thread, or the question on the table.

    line 43
  6. Distinctive:

    Do not ask anything yet; mapping first prevents premature commitment to a path.

    line 45
  7. Distinctive:

    Prefer load-bearing questions over leaf-level details that can wait.

    line 50
  8. Distinctive:

    If the question can be answered by reading the code, read the relevant files first.

    line 54
  9. Distinctive:

    Only ask the user if real ambiguity remains after the read.

    line 55
  10. Distinctive:

    When it arrives, if the next branch's question does NOT depend on that answer, ask it IMMEDIATELY — before processing the answer — then …

    line 68
  11. Distinctive:

    When an answer arrives, update the decision tree.

    line 75
  12. Distinctive:

    All design branches have explicit decisions

    line 86

“Common” is measured: kept by at least 6 in 10 of the 178 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Ask dependent questions one at a time; batch answer-independent questions into one card so the user never waits between them (owner directive 2026-07-21).

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

Prerequisites

  • User inputs & decisions: an available user for interactive dialogue — the plan, design, or question to pressure-test (via $ARGUMENTS or shared context), and an answer to each batched/dependent question as the interview proceeds. This skill is interactive by design; the interview IS the skill's purpose, not a mid-run gap.
  • Tools: Read, Grep, Glob (already declared above) to explore the codebase before asking anything answerable from it. No credentials, external services, or network access.

No STEP 0 — beyond the user's presence/topic and the read-only tools already declared, there are no environmental prerequisites to preflight.

When to use

  • The user has a plan, design, spec, or proposed approach they want pressure-tested
  • The user says "grill me", "stress-test this", "drill into this", or "interview me"
  • Before committing to a non-trivial architectural decision
  • When the user is uncertain whether their plan covers all the branches

When NOT to use

  • Pure factual questions with a single correct answer
  • Tasks where the user has already decided and just wants execution
  • Quick yes/no clarifications (a single clarification question is enough)

STEP 1: Map the decision tree

Read whatever context the user shared — a plan file, a message thread, or the question on the table. List the top-level decision points along with the dependencies between them. Do not ask anything yet; mapping first prevents premature commitment to a path.

STEP 2: Pick the first unresolved branch

Choose the branch with the highest leverage — the one whose answer constrains the most downstream decisions. Prefer load-bearing questions over leaf-level details that can wait.

STEP 3: Read the codebase before asking

If the question can be answered by reading the code, read the relevant files first. Only ask the user if real ambiguity remains after the read. This prevents wasting the user's time on questions you could have answered yourself.

STEP 4: Ask the next question(s) with your recommended answer

Frame each question as a single decision with an explicit recommendation. Example: "Should X be A or B? Recommended: A, because Y." Batch questions ONLY when they are answer-independent (neither's existence nor wording depends on the other's answer); a dependent question waits for its turn.

STEP 5: Wait for the response

Block on the user's answer. When it arrives, if the next branch's question does NOT depend on that answer, ask it IMMEDIATELY — before processing the answer — then process while the user types. Do not move deeper into the current branch until it is resolved or explicitly deferred.

STEP 6: Update the tree and repeat

When an answer arrives, update the decision tree. New branches may appear; mark them. Loop back to STEP 2 with the updated tree.

STEP 7: Stop when the tree is resolved

The interview ends when every branch has an explicit decision OR the user signals satisfaction. Summarize the resolved decisions back to the user as a final checkpoint.

Stopping conditions

  • All design branches have explicit decisions
  • The user says "stop", "enough", "I'm convinced", or similar
  • A blocker emerges that requires research before the interview can continue
  • The plan has changed enough that re-mapping is needed before continuing

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.