grill-me

Stress-test plans by resolving assumptions, dependencies, tradeoffs, and risks through one-question-at-a-time interviews.

Updated Sep 16, 2025
One-click install
npx skills add https://github.com/slingr-stack/qa-test-drumr --skill grill-me-slingr-stack
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: grill-me
Source: https://github.com/slingr-stack/qa-test-drumr/tree/main/.github/skills/grill-me
Command: npx skills add https://github.com/slingr-stack/qa-test-drumr --skill grill-me-slingr-stack

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you rigorously stress-test a plan, design, or proposal by forcing clarity on goals, assumptions, tradeoffs, and risks before implementation begins.

Core Features & Use Cases

  • Branch-by-Branch Interrogation: It asks exactly one focused question at a time to resolve the highest-leverage unresolved decision first.
  • Dependency-Aware Review: It checks repository context when possible, so it can answer from existing code, docs, or configuration instead of guessing.
  • Decision Convergence: It surfaces hidden assumptions, recommends default answers, and keeps the discussion moving until the major branches are decided or explicitly deferred.

Quick Start

Ask the Skill to grill your proposed plan, architecture, or implementation strategy and it will begin with the first blocking question.

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 software architecture before implementation?

To stress-test a software architecture, you can use a branch-by-branch interview process that asks one focused question at a time to resolve assumptions, dependencies, and tradeoffs. This structured design review identifies remaining risks and recommends default answers to converge on a solid decision log.

What is a decision tree interview for design review?

A decision tree interview for design review is a structured interrogation method that forces clarity on goals and risks by resolving the highest-leverage unresolved branch first. It surfaces hidden assumptions and keeps discussion moving until major tradeoffs are explicitly decided or deferred.

How do I identify hidden assumptions in a product proposal?

You identify hidden assumptions in a product proposal by running a rigorous interrogation that checks repository context, code, and docs. This dependency-aware review resolves unresolved branches one question at a time and outputs a concise log of remaining assumptions and next steps.

Can I evaluate implementation strategies using a one-question-at-a-time interview?

Yes, you can evaluate implementation strategies using a one-question-at-a-time interview to rigorously pressure-test plans. It applies branch-by-branch review to your strategy, recommends default answers for unresolved decisions, and generates a decision log with next steps.

What is the best way to resolve tradeoffs in a technical design?

The best way to resolve tradeoffs in a technical design is through a structured interview that inspects repository context to answer from existing code instead of guessing. It surfaces dependencies, recommends default answers, and defers non-blocking branches to keep the review moving.

When should I not use a branch-by-branch interrogation for my plan?

You should avoid branch-by-branch interrogation for plans that lack unresolved architectural branches or require immediate execution. This rigorous review process is designed for complex decisions needing rigorous tradeoff analysis, dependency checks, and a formal decision log rather than simple, straightforward tasks.