grill-me

Interrogate plans and designs to expose assumptions and unresolved dependencies.

8|Updated Jan 19, 2026
One-click install
npx skills add https://github.com/OiAnthony/.agents --skill grill-me-oianthony
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: grill-me
Source: https://github.com/OiAnthony/.agents/tree/main/skills/grill-me
Command: npx skills add https://github.com/OiAnthony/.agents --skill grill-me-oianthony

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you pressure-test a plan or design before committing to it, surfacing hidden assumptions, unresolved tradeoffs, and missing dependencies early.

Core Features & Use Cases

  • Relentless Structured Interviewing: Walks through a decision tree one question at a time until the plan is mutually understood.
  • Branch-by-Branch Resolution: Resolves each dependency and follow-up decision before moving to the next topic.
  • Codebase-Aware Clarification: Checks the repository when a question can be answered by inspecting existing code instead of guessing.
  • Use Case: Use it when you want to review a feature idea, challenge an architecture choice, or get thoroughly grilled on a proposal before implementation.

Quick Start

Ask the Skill to grill your plan or design and answer its questions one at a time until all major branches are resolved.

Frequently Asked Questions about grill-me

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I stress-test a technical design before implementation?

To stress-test a design, use structured one-question-at-a-time interviewing to interrogate the plan, exposing hidden assumptions and unresolved dependencies. This relentless approach surfaces missing decisions and tradeoffs early, ensuring the architecture is thoroughly reviewed before committing to execution.

What is a decision tree interview for feature planning?

A decision tree interview for feature planning is a structured method that resolves dependencies branch-by-branch. By walking through a proposal one question at a time, it ensures every follow-up decision is mutually understood and verified before moving to the next architectural topic.

Can I verify assumptions against my codebase during a design review?

Yes, you can verify assumptions against your codebase during a design review by inspecting the repository directly. Whenever a question about existing code or architecture arises, the review process checks the actual codebase to clarify answers instead of guessing.

What's the best way to expose hidden tradeoffs in a proposal?

The best way to expose hidden tradeoffs in a proposal is through relentless pressure-testing. By systematically resolving each dependency and follow-up decision before moving forward, you surface unresolved architectural choices and missing dependencies early in the planning stage.

When do I need rigorous stress-testing for architecture discussions?

You need rigorous stress-testing for architecture discussions when committing to a plan requires exposing hidden assumptions and unresolved dependencies. It is essential for proposal reviews, architecture choices, and feature planning to ensure all major branches are resolved before execution.