grill-me

Interrogate plans and designs by questioning assumptions, dependencies, and decisions.

10|Updated Mar 21, 2026
One-click install
npx skills add https://github.com/tincopper/neeko --skill grill-me-tincopper
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: grill-me
Source: https://github.com/tincopper/neeko/tree/main/.agents/skills/grill-me
Command: npx skills add https://github.com/tincopper/neeko --skill grill-me-tincopper

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill removes ambiguity from plans and designs by forcing the hidden assumptions, tradeoffs, and unresolved dependencies into the open before work begins.

Core Features & Use Cases

  • Structured Interrogation: Walks through a plan one decision at a time and keeps pushing until each branch is understood.
  • Recommendation Included: For every question, it offers a suggested answer so the user has a concrete starting point.
  • Codebase-Aware Follow-Up: If a question can be answered by exploring the repository, it checks the codebase instead of guessing.
  • Use Case: Helpful for architecture reviews, product design debates, implementation planning, and any situation where a proposal needs stress-testing.

Quick Start

Use the grill-me skill to question this design proposal until every major assumption, dependency, and decision is 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 an architecture design before implementation?

An architecture review validates proposals by interrogating every assumption, dependency, and decision one question at a time. It includes recommended answers for each branch and explores the codebase for evidence, clarifying the design before implementation begins.

What is the best way to find unresolved dependencies in a product proposal?

Finding unresolved dependencies in a product proposal requires structured interrogation that pushes each decision branch until understood. The process provides recommended answers for each question and uses codebase exploration to resolve dependencies using repository evidence.

How do I clarify ambiguous implementation plans with a decision tree?

Clarifying ambiguous implementation plans involves walking through each decision one question at a time until every branch is understood. This structured interrogation exposes hidden assumptions and tradeoffs, providing recommended answers to resolve ambiguity before work starts.

Can I use codebase exploration to answer questions during a design review?

Yes, you can use codebase exploration to answer questions during a design review. Whenever a question can be resolved using repository evidence, the codebase is explored directly instead of guessing, ensuring the design review is grounded in actual code.

Does this approach work for branch-heavy decision processes?

Yes, this approach works for branch-heavy decision processes such as architecture reviews, implementation planning, and product proposals. It systematically interrogates every unresolved assumption and dependency across all branches until the proposal is fully understood.