auto-grill

Files (1)

• SKILL.md

SKILL.md (first lines)

# Auto-Grill

Replaces the manual two-tab workflow: grill-me in one tab, codebase Q&A in
another. The griller stays adversarially blind to the code so questions are
generated from pure reasoning, not confirmation bias.

## Invocation

```
/auto-grill                              # prompts for plan
/auto-grill 15                           # 15 questions instead of 10
/auto-grill @path/to/file.py             # attach file as extra context
/auto-grill @plan.md @models.py 12       # multiple context files + count
```

`@<path>` args are read and passed to the researcher (not the griller).
A bare number sets the question count. Everything else is the plan inline.

---

## Step 1: Gather inputs

Parse args:
- `@<path>` tokens - read each file, label it by filename, collect as CONTEXT
- a bare integer - question count (default: 10)
- anything else - the plan

If no plan is found in args, ask the user to paste it.

Tell the griller only which context filenames exist - not their content.
This preserves the adversarial separation: the griller cannot see the answers.

---

## Step 2: Griller agent

Spawn a general-purpose agent with no codebase access. Give it the plan
and the list of context filenames (not contents).

The griller's job is adversarial: generate questions that would embarrass the
plan. It should not look anything up - only reason from the plan text.

```
You are a senior engineer adversarially reviewing a plan. Generate [N] hard
questions that stress-test assumptions, expose ambiguities, probe edge cases,
and challenge design decisions. Do NOT search the codebase or look anything
up - generate questions from pure reasoning about the plan.

Rules:
- Specific and concrete only (not "have you considered edge cases?")
- Cover: data model assumptions, state machine transitions, concurrency,
  failure modes, backwards compatibility, missing requirements,
  performance at scale, security boundaries
- Tag each question: [CODE] if answerable by reading code,
  [JUDGMENT] if it needs a human decision, [BOTH] if it needs both
- Number each question 1 through N
- Questions only - no answers

[If context files were attached]:
Note: reviewers have access to these files: [list filenames only]

Plan:
[PLAN TEXT]
```

---

## Step 3: Researcher agent

Spawn an Explore agent (or general-purpose with full tools). Give it the
[CODE] and [BOTH] questions, the plan, the working directory, and any
attached context files.

Skip [JUDGMENT]-only questions here - they go directly to the user in Step 4.

```
You are answering adversarial review questions about a plan. For each
question, search the actual codebase to find the real answer. Read models,
migrations, existing code, tests, and context files - do not guess.

Output format for each question:
**Q[N]**: [question text]
**Answer**: [what you found in code/docs/context]
**Confidence**: HIGH / MEDIUM / LOW
**Gap**: YES / NO
**Notes**: [if confidence < HIGH or gap is YES, explain what is missing
           or contradictory]

Codebase root: [working directory]

Check these context files first if they exist:
- lib/ai-codebase-context/_common/index.md
- lib/ai-codebase-context/_common/state-machines.md
- CLAUDE.md

[If attached context]:
Additional context provided by user:
[CONTEXT FILE CONTENTS WITH FILENAMES AS HEADERS]

Questions to answer:
[GRILLER OUTPUT - CODE and BOTH questions only]

Plan:
[PLAN TEXT]
```

---

## Step 4: Human decision points

After the researcher returns, collect every question that needs human judgment:
- All [JUDGMENT]-tagged questions
- All [BOTH] questions where researcher returned Confidence < HIGH or Gap = YES

For each decision, use `AskUserQuestion` (or plain-text prompt if unavailable):
- Header: short label, e.g. "Retry strategy"
- Question: the griller's exact question
- Options: 2-4 concrete choices derived from the plan and researcher findings,
  plus "Other / I'll explain"

From bymatej/skills, MIT.

More from bymatej/skills