ia-brainstorming

Guides pre-implementation design exploration and produces versioned documents in docs/brainstorms.

30|3|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/iliaal/whetstone --skill ia-brainstorming
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ia-brainstorming
Source: https://github.com/iliaal/whetstone/tree/main/plugins/whetstone/skills/ia-brainstorming
Command: npx skills add https://github.com/iliaal/whetstone --skill ia-brainstorming

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you clarify what to build from a vague or ambiguous feature idea before any coding starts, producing a design document after structured discovery and trade-off exploration.

Core Features & Use Cases

  • Design-first exploration: runs deep interview-style questioning, compares 2-3 approaches, and ensures you only proceed after explicitly approving the design.
  • Scope decomposition gate: detects when the request spans independent subsystems and splits the work into separate brainstorm → plan → implementation cycles.
  • Design-doc capture and self-review: outputs a versioned artifact saved under docs/brainstorms with required sections and an anti-TBD checklist.

Quick Start

Tell your AI agent: "Brainstorm ideas for a new notification system so we can approve a design before implementing."

Frequently Asked Questions about ia-brainstorming

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

FAQPage Schema
How do I turn vague feature requests into an approved design doc?

To turn vague feature requests into an approved design doc, use structured pre-implementation exploration. This process applies interview-style questioning to clarify ambiguous requirements and explore trade-offs, ensuring design approval before any coding begins.

What is scope decomposition in software design, and when do I need it?

Scope decomposition in software design splits complex requests spanning independent subsystems into separate cycles. You need it when a vague feature request covers multiple subsystems, requiring decomposition into distinct brainstorm, plan, and implementation phases before proceeding.

How do I structure brainstorming and trade-off analysis before writing code?

Structure brainstorming and trade-off analysis by comparing 2-3 approaches during deep interview-style questioning. This captures explicit design gates and outputs a versioned artifact under docs/brainstorms, ensuring you address all trade-offs before implementation.

Can I use design-first exploration for ambiguous requirements across multiple subsystems?

Yes, you can use design-first exploration for ambiguous requirements across multiple subsystems. It detects when requests span independent subsystems and splits the work into separate brainstorm and implementation cycles to handle the complexity systematically.

Does the design doc capture process include a self-review checklist?

Yes, the design doc capture process includes an anti-TBD checklist for self-review. It outputs a versioned artifact saved under docs/brainstorms with required sections, ensuring no unresolved items remain before the design is explicitly approved.

Why avoid coding when requirements are unclear and trade-offs are unresolved?

Avoiding coding when requirements are unclear prevents building the wrong solution. Pre-implementation exploration resolves ambiguity and maps trade-offs first, producing an approved design document rather than premature code that might miss subsystem dependencies.