Grill-Me: Hardening Plans Before They Reach Code

Where this fits

You've just written a rollout plan for a multi-team migration, and you know it has gaps—but you can't see them because you wrote it. Instead of asking a colleague to read it, you say "grill me." The agent inspects the plan, cross-checks it against the actual codebase and adjacent docs, asks only about real conflicts, and edits the plan file in place until it's coherent enough to execute or clearly blocked.

Why agents benefit

• Evidence-backed questioning: The agent reads your code and docs first, so it auto-answers questions that are already resolved and only surfaces genuine conflicts or low-confidence recommendations.
• In-place editing: It updates the source-of-truth file directly—no separate chat summary that drifts out of sync. Conclusions, blockers, readiness, and deferred work stay synchronized in the document.
• Format preservation: The artifact keeps its original structure and tone, so the output remains useful for stakeholders who don't use agents.
• Explicit selection discipline: If multiple candidate files exist, the agent forces you to pick one before editing, preventing accidental modifications to the wrong plan.
• Blocking clarity: Instead of endless back-and-forth, the agent declares the plan either ready for the next step or plainly blocked, with the blocker stated in the file.

Practical scenarios

Pre-implementation design review

You have a PRD for a new feature. The agent compares it against existing API contracts and data models, finds three places where the proposed flow contradicts current behavior, and rewrites the PRD to resolve those conflicts—or marks them as open blockers.

Migration runbook validation

You're about to run a database migration. The agent reads the runbook, checks the actual schema files, and flags steps that assume indexes that don't exist. It updates the runbook's readiness section and adds a rollback note.

Rolling-wave project shape

You've planned a wave-based rollout across teams. The agent reviews the wave definitions against dependency graphs in your repo, spots a team scheduled before its upstream dependency, and adjusts the wave boundaries in the plan file.

Add it to your agent workflow

Install with:

npx skills add rijkvanzanten/rolling-wave-engineering --skill grill-me

Then invoke it in a session where your plan file is present:

codex --skill grill-me "grill me on ./docs/rollout-plan.md"

The agent will inspect the file, cross-reference code, and edit the plan directly. Review the diff before committing.

Compare before adopting

Before adding this skill, compare it against alternatives: check the repo's commit frequency and issue responses (a 13-star project may be early), read the README for workflow assumptions, and test whether the agent's edits match your document conventions. Also weigh it against simpler prompts that just ask for review—but note that those won't persist state in the artifact.

Why it is worth tracking

This skill solves a real pain: plans that look done but aren't. Its quality signal is the "edit in place" behavior—rare among review skills—and its focus on evidence-backed questions. The project is young, so evaluate it on a low-stakes doc first. If it handles your format and workflow cleanly, it could become a standard step before any large implementation. For more context, see the skill page on OpenAgentSkill.