Dev Grill

The AI grills your understanding instead of you reviewing its code.

Code is now cheap to generate and expensive to stay connected to. Reading 10k lines of AI-generated code a day is neither fun nor sustainable. dev-grill inverts the review: it interviews you, one decision-branch at a time, until you both reach shared understanding of what's being built and why each significant decision was made — then hands back a compact, language-agnostic summary you can drop into an RFC, a spec, or a PR gate.

It is the shared engine. Two adapters plug into it:

Where	Moment	Input	Output goes to
dev-grill (/grill)	any	plan / design / diff / module / incident	a file you can save
dev-spec-driven (/grill)	before code	requirements	folded into requirements.md as EARS
dev-guardian (/guardian-grill)	before merge	the diff/PR	a 🟢/🟡/🔴 understanding verdict

The interrogation method lives in one place (skills/dev-grill/SKILL.md). The adapters are thin: they only decide what to feed the engine and where the answer goes. Tune the method once, everything improves.

What it grills

Domain-significant decisions only — business-rule branches, validation & failure paths, in/out of scope, unit contracts (inputs/outputs), state changes and edge cases. It deliberately does not grill formatting or naming — that's what a quality gate / linter is for (dev-guardian).

Modes & depth

Five modes (it infers if you don't say):

• plan — grill an idea before code exists.
• design — pressure-test a written design/architecture.
• diff — confirm you understand the decisions a diff/PR introduced.
• onboarding — grill your understanding of an existing/inherited module.
• postmortem — grill your understanding of an incident's actual causal chain.

Depth: --quick (~3 questions, riskiest branch), default (5–15 adaptive), --deep (exhaustive).

Usage

/grill plan     let's build a notification service
/grill diff     # grills the domain decisions in your current git diff
/grill onboarding src/billing   # grills what you understand about inherited code
/grill diff --deep              # exhaustive
/grill          # infers the mode from what you paste

Every grill ends with a Shared Understanding summary — Purpose, a language-agnostic Contract, Domain decisions & rationale, Edge cases, out-of-scope, and a Decision-coverage map (✅/❓/⚠️) that makes the result auditable. You can pause a long grill and resume it later.

Works in every AI (no MCP needed)

dev-grill is a pure prompt engine, so it ports to any host as plain text — the method into the host's rules file, and /grill into its command surface. Supported: Claude Code, Cursor, Gemini CLI, GitHub Copilot / VS Code, Windsurf, OpenAI Codex, and any generic AGENTS.md reader (Cline, Roo, Zed, Continue).

Three ways to wire it up:

1. Auto-setup (easiest). Install in Claude Code; the first time you open a project it asks once whether to wire /grill into the other AIs, and does it for you on yes. Writes nothing without your consent; disable with DEV_GRILL_AUTOSETUP=off. Or trigger it any time with /grill-setup.
2. Installer CLI. node bin/dev-grill.mjs install all --project /path/to/repo (idempotent, reversible, --dry-run to preview). node bin/dev-grill.mjs list shows every host.
3. By hand. Copy the files from host-rules/ — see INTEGRATIONS.md.

Install

Drop this folder next to your other plugins and enable it as a Claude Code plugin. It has no MCP server and no dependencies — it's a prompt engine (skills + commands) plus a dependency-free installer and a fail-open auto-setup hook.

Design notes

• One question at a time. Always. A questionnaire dump defeats the purpose.
• Language-agnostic output. The summary captures inputs/outputs/validation/domain rules, not implementation — so the same understanding can seed Go, Rust, or TypeScript.
• An honest 🟡 beats a false 🟢. If you can't explain a branch, that's a finding, not a failure.
• Trilingual. Responds in your language (EN/PT/ES).

MIT · Carlos Pereira