GUIDE

name: brainstorming
description: "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."

Brainstorming Ideas Into Designs

Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.

<HARD-GATE> Do NOT invoke any implementation skill, write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it. This applies to EVERY project regardless of perceived simplicity. </HARD-GATE>

Anti-Pattern: "This Is Too Simple To Need A Design"

Every project goes through this process. A todo list, a single-function utility, a config change — all of them. "Simple" projects are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple projects), but you MUST present it and get approval.

Checklist

You MUST create a task for each of these items and complete them in order:

1. **Explore project context** — check files, docs, recent commits 2. **Offer the visual companion just-in-time** — NOT upfront. The first time a question would genuinely be clearer shown than described, offer it then (its own message); on approval its browser tab opens for you. If no visual question ever arises, never offer it. See the Visual Companion section below. 3. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria 4. **Propose 2-3 approaches** — with trade-offs and your recommendation 5. **Present design** — in sections scaled to their complexity, get user approval after each section 6. **Write design doc** — save to `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` and commit 7. **Spec self-review** — quick inline check for placeholders, contradictions, ambiguity, scope (see below) 8. **User reviews written spec** — ask user to review the spec file before proceeding 9. **Transition to implementation** — invoke writing-plans skill to create implementation plan

Process Flow

The terminal state is invoking writing-plans. Do NOT invoke frontend-design, mcp-builder, or any other implementation skill. The ONLY skill you invoke after brainstorming is writing-plans.

The Process

**Understanding the idea:**

• Check out the current project state first (files, docs, recent commits)
• Before asking detailed questions, assess scope: if the request describes multiple independent subsystems (e.g., "build a platform with chat, file storage, billing, and analytics"), flag this immediately.
• If the project is too large for a single spec, help the user decompose into sub-projects.
• For appropriately-scoped projects, ask questions one at a time to refine the idea
• Prefer multiple choice questions when possible
• Only one question per message
• Focus on: purpose, constraints, success criteria

**Exploring approaches:**

• Propose 2-3 different approaches with trade-offs
• Present options conversationally with your recommendation
• Lead with your recommended option

**Presenting the design:**

• Scale each section to its complexity
• Ask after each section whether it looks right
• Cover: architecture, components, data flow, error handling, testing

**Design for isolation and clarity:**

• Break the system into smaller units that each have one clear purpose
• For each unit: what does it do, how do you use it, what does it depend on?
• Smaller, well-bounded units are easier to reason about

**Working in existing codebases:**

• Explore the current structure before proposing changes
• Include targeted improvements as part of the design
• Don't propose unrelated refactoring

After the Design

**Documentation:**

• Write the validated design to `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md`
• Commit the design document to git

**Spec Self-Review:** 1. Placeholder scan: Any TBD, TODO, incomplete sections? 2. Internal consistency: Any contradictions? 3. Scope check: Focused enough for a single plan? 4. Ambiguity check: Could any requirement be interpreted two ways?

**User Review Gate:** Wait for user to approve the spec before proceeding.

**Implementation:**

• Invoke the writing-plans skill
• Do NOT invoke any other skill

Key Principles

• **One question at a time**
• **Multiple choice preferred**
• **YAGNI ruthlessly**
• **Explore alternatives**
• **Incremental validation**
• **Be flexible**

Visual Companion

A browser-based companion for showing mockups, diagrams, and visual options during brainstorming. Available as a tool — not a mode. Offer just-in-time when a question truly needs visuals.