· 1 observation
Technical updates · 1
Package or technical metadata updated
View technical comparison →Saul Martí v2.0.0
Interrogate plans and ideas
From the developer
Not specified in the available declarations: limitations, pricing & account requirements.
Grill me on this feature idea until the decisions are clear
Developer declarations; not independently tested. Listing last checked Nov 22, 2026. Package observed Nov 21, 2026.
From the marketplace listing
Sharpen an idea, plan, or design through a demanding interview. Uses Matt grilling workflows by default and can use idea-refinement or intent-interview helpers when appropriate.
Language: English · Automatically detected from descriptions.
· 1 observation
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →Package or technical metadata updated
View technical comparison →Finding similar plugins… Results will appear here automatically.
Browse plugins →--- name: domain-modeling description: Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a CONTEXT.md, or recording or editing an ADR. disable-model-invocation: true --- # Domain Modeling Actively build and sharpen the project's domain model as you design. This is the *active* discipline: challenging terms, inventing edge-case scenarios, and writing the glossary and decisions down the moment they crystallise. (Merely *reading* `CONTEXT.md` for vocabulary is not this skill: that's a one-line habit any skill can do. This skill is for when you're changing the model, not just consuming it.) ## File structure Most repos have a single context: ``` / ├── CONTEXT.md ├── docs/ │ └── adr/ │ ├── 0001-event-sourced-orders.md │ └── 0002-postgres-for-write-model.md └── src/ ``` If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives: ``` / ├── CONTEXT-MAP.md ├── docs/ │ └── adr/ ← system-wide decisions ├── src/ │ ├── ordering/ │ │ ├── CONTEXT.md │ │ └── docs/adr/ ← context-specific decisions │ └── billing/ │ ├── CONTEXT.md │ └── docs/adr/ ``` Create files lazily: only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed. ## During the session ### Challenge against the glossary When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y. Which is it?" ### Sharpen fuzzy language When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account': do you mean the Customer or the User? Those are different things." ### Discuss concrete scenarios When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts. ### Cross-reference with code When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible. Which is right?" ### Update CONTEXT.md inline When a term is resolved, update `CONTEXT.md` right there. Don't batch these up: capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md). `CONTEXT.md` should be totally devoid of implementation details. Do not treat `CONTEXT.md` as a spec, a scratch pad, or a repository for implementation decisions. It is a glossary and nothing else. ### Offer ADRs sparingly Only offer to create an ADR when all three are true: 1. **Hard to reverse**: the cost of changing your mind later is meaningful 2. **Surprising without context**: a future reader will wonder "why did they do it this way?" 3. **The result of a real trade-off**: there were genuine alternatives and you picked one for specific reasons If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
Referenced files: 3 — file references are metadata, not package contents.
--- name: entry-grill-me description: "Use whenever the GrillMe plugin is selected. Route the request to the intended bundled workflow while keeping all dependencies internal to this plugin." --- # GrillMe This is the public entry workflow for this plugin. The bundled skills below are dependencies, not competing entry points. ## Mandatory routing For an explicit grill request use grill-with-docs when a working repository is available and grill-me otherwise. Use idea-refine for ideation and interview-me for intent discovery. Never implement final work from this plugin. If a bundled workflow calls another bundled skill, invoke that local bundled copy. Never require the user to install another plugin to complete this workflow. ## Bundled workflows - `grill-me` - `grill-with-docs` - `grilling` - `domain-modeling` - `idea-refine` - `interview-me` - `loop-me`
--- name: grilling description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases. disable-model-invocation: true --- Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round. Format a round like so: ``` ❓ **Q1** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices> ➡️ <your recommended answer> --- ❓ **Q2** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices> ➡️ <your recommended answer> ``` Each round the user answers reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a _later_ round, not this one. Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent to find it; don't ask the user for anything you could look up yourself. Don't block on it: a running exploration is an unsettled prerequisite, so only the questions downstream of it wait for the sub-agent to report; ask the rest of the frontier now. The _decisions_ are the user's: put each to them and wait. The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding.
Referenced files: 1 — file references are metadata, not package contents.
--- name: grill-me description: A relentless interview to sharpen a plan or design. disable-model-invocation: true --- Call the Skill tool with "grilling".
Referenced files: 1 — file references are metadata, not package contents.
--- name: grill-with-docs description: A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go. disable-model-invocation: true --- Call the Skill tool twice, for "grilling" and "domain-modeling".
Referenced files: 1 — file references are metadata, not package contents.
--- name: idea-refine description: Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan". disable-model-invocation: true --- # Idea Refine Refines raw ideas into sharp, actionable concepts worth building through structured divergent and convergent thinking. ## How It Works 1. **Understand & Expand (Divergent):** Restate the idea, ask sharpening questions, and generate variations. 2. **Evaluate & Converge:** Cluster ideas, stress-test them, and surface hidden assumptions. 3. **Sharpen & Ship:** Produce a concrete markdown one-pager moving work forward. ## Usage This skill is primarily an interactive dialogue. Invoke it with an idea, and the agent will guide you through the process. ```bash # Optional: Initialize the ideas directory bash skills/idea-refine/scripts/idea-refine.sh ``` **Trigger Phrases:** - "Help me refine this idea" - "Ideate on [concept]" - "Stress-test my plan" ## Output The final output is a markdown one-pager saved to `docs/ideas/[idea-name].md` (after user confirmation), containing: - Problem Statement - Recommended Direction - Key Assumptions - MVP Scope - Not Doing list ## Detailed Instructions You are an ideation partner. Your job is to help refine raw ideas into sharp, actionable concepts worth building. ### Philosophy - Simplicity is the ultimate sophistication. Push toward the simplest version that still solves the real problem. - Start with the user experience, work backwards to technology. - Say no to 1,000 things. Focus beats breadth. - Challenge every assumption. "How it's usually done" is not a reason. - Show people the future — don't just give them better horses. - The parts you can't see should be as beautiful as the parts you can. ### Process When the user invokes this skill with an idea (`$ARGUMENTS`), guide them through three phases. Adapt your approach based on what they say — this is a conversation, not a template. #### Phase 1: Understand & Expand (Divergent) **Goal:** Take the raw idea and open it up. 1. **Restate the idea** as a crisp "How Might We" problem statement. This forces clarity on what's actually being solved. 2. **Ask 3-5 sharpening questions** — no more. Focus on: - Who is this for, specifically? - What does success look like? - What are the real constraints (time, tech, resources)? - What's been tried before? - Why now? Use the `AskUserQuestion` tool to gather this input. Do NOT proceed until you understand who this is for and what success looks like. 3. **Generate 5-8 idea variations** using these lenses: - **Inversion:** "What if we did the opposite?" - **Constraint removal:** "What if budget/time/tech weren't factors?" - **Audience shift:** "What if this were for [different user]?" - **Combination:** "What if we merged this with [adjacent idea]?" - **Simplification:** "What's the version that's 10x simpler?" - **10x version:** "What would this look like at massive scale?" - **Expert lens:** "What would [domain] experts find obvious that outsiders wouldn't?" Push beyond what the user initially asked for. Create products people don't know they need yet. **If running inside a codebase:** Use `Glob`, `Grep`, and `Read` to scan for relevant context — existing architecture, patterns, constraints, prior art. Ground your variations in what actually exists. Reference specific files and patterns when relevant. Read `frameworks.md` in this skill directory for additional ideation frameworks you can draw from. Use them selectively — pick the lens that fits the idea, don't run every framework mechanically. #### Phase 2: Evaluate & Converge After the user reacts to Phase 1 (indicates which ideas resonate, pushes back, adds context), shift t
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 4 — file references are metadata, not package contents.
---
name: interview-me
description: Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invokes ("interview me", "grill me", "are we sure?", "stress-test my thinking"), or when you catch yourself silently filling in ambiguous requirements before any plan, spec, or code exists.
disable-model-invocation: true
---
# Interview Me
## Overview
What people ask for and what they actually want are different things. They ask for "a dashboard" because that's what one asks for, not because a dashboard solves their problem. They say "make it faster" without a number to hit.
The cheapest moment to find this gap is before any plan, spec, or code exists. Once you've started building, switching costs are real, and the user will rationalize the wrong thing into a "good enough" thing. The misfit gets locked in.
This skill closes the gap before it costs anything. The other Define-phase skills assume you already know roughly what you want: `idea-refine` generates variations from an idea, `spec-driven-development` writes the requirements down, `doubt-driven-development` stress-tests a plan after you've drafted one. Interview-me is the part before all of those, where you ask one question at a time, with your best guess attached, until you can predict what the user is going to say before they say it.
## When to Use
Apply this skill when:
- The ask is missing at least one of: **who** the user is, **why** they want it, what **success** looks like, what the binding **constraint** is
- The request is conventional rather than specific ("build me X", "make it faster") and you can't unpack the convention without guessing
- You're tempted to start with assumptions you haven't surfaced
- The user hasn't said which value they're optimizing for when two reasonable ones are in tension (simplicity vs. flexibility, cost vs. speed)
- The user explicitly invokes: "interview me", "grill me", "before we start, are we sure?", "stress-test my thinking"
**When NOT to use:**
- The ask is unambiguous and self-contained ("rename this variable", "fix this typo")
- The user has explicitly asked for speed over verification
- Pure information requests ("how does X work?", "what does this code do?")
- Mechanical operations (renames, formats, file moves)
- You already have ≥95% confidence; re-read the stop condition below before assuming you don't
## Loading Constraints
This skill needs a live, responsive user. **Do not invoke in non-interactive contexts** like CI pipelines, scheduled runs, `/loop`, or autonomous-loop. If you're in one of those and the ask is underspecified, flag that as a blocker for the user instead of guessing.
## The Process
### Step 1: Hypothesize, with a confidence number
Before asking anything, write down your current best read of what the user wants in **one sentence**, plus an honest confidence number (0–100%):
```
HYPOTHESIS: You want a way to answer "how are we doing?" in standup, and "dashboard" was the convention that came to mind.
CONFIDENCE: ~30% — missing: who it's for, what "metrics" means in context, and what success looks like
```
The number forces honesty. If you wrote down a high number but can't actually predict the user's reactions to the next three questions you'd ask, the number is wrong. Start at the confidence level you can defend.
When confidence is below ~70%, append a brief reason on the same line — what's still unresolved or missing. This tells the user exactly what the interview needs to surface, and prevents the number from being a vague signal.
### Step 2: Ask one question at a time, each with a guess attached
Format:
```
Q: <one focused question>
GUESS: <your hypothesis for the answer, with the reasoning that produced it>
```
Wait for the user to react before asking tPreview of the first 4,000 characters. Read full instructions →
--- name: loop-me description: Grill me about specs for the workflows I want to build, within this workspace. disable-model-invocation: true argument-hint: "A workflow to design, or nothing to go find one" --- Run a stateful `/grilling` session whose only output is **workflow** specs. Use the grilling discipline (relentless, a round of questions at a time, a recommended answer attached to each) aimed at the vocabulary and goal below. Create, edit, and delete specs as the grilling resolves things. ## The loop lens A **loop** is a recurring pattern in the user's life: their career, their week, their morning, a single repeated activity. Picturing a life as loops within loops reveals how predictable its activities really are, which is what makes them worth **delegating**. Use the lens to find loops worth specifying, and propose ones the user hasn't noticed. A **workflow** is the spec of one loop, made real. You run a workflow on a loop: the loop is its running instantiation. Workflows live in `workflows/*.md` and are the source of truth. ## Vocabulary A shared language, reached for only when a workflow calls for it: never a checklist. **Mandate nothing structural**: a workflow needs no AI, no checkpoint, and no schedule unless the grilling shows it does. - **Trigger**: what fires each run, an **event** (a new email, a new issue) or a **schedule** (every morning). Event-triggering is usually the more efficient. - **Checkpoint**: a human-in-the-loop point where the user is asked to verify or decide. Some workflows have none and run autonomously; some use no AI at all. - **Push right**: defer the checkpoint as far as it will go. Do maximal work before involving the human, so they are asked once, late, with everything prepared. - **Brief**: what a checkpoint presents, a tight, decision-ready summary (what was produced, why, and a link down to the asset itself), never the raw output. The user reads a brief, not a draft. Speed of review is imperative. ## Definition of done A workflow spec is done when an implementer agent could build it without asking a single question. Grill until then; nothing is done while a question remains. ## The workspace - `workflows/*.md`: one spec per workflow. - `NOTES.md`: raw notes on the user's world, the tools they use, the channels they process, and their own terminology for both. When it is empty or thin, interview them about their world before specifying anything. Sharpen fuzzy terms into canonical ones as they surface, and record them here.
Referenced files: 1 — file references are metadata, not package contents.
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
Package observed Nov 21, 2026.
plugins_6aa30960611c8191b70ef0323cce74a0
Download plugin data (JSON)Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.