brainstorming

Use when starting any feature, project, or design work. Guides collaborative design refinement through incremental questioning before any code is written.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

The Brainstorming skill is a collaborative design framework for Claude that prioritizes architectural planning and requirement refinement before a single line of code is written. By utilizing incremental questioning and the YAGNI (You Ain't Gonna Need It) principle, it helps developers and product managers avoid over-engineering, align on technical trade-offs, and create comprehensive design documentation for any new feature or project.

Use Cases

  • Initial Feature Scoping: Clarifying project goals, user constraints, and success metrics through structured, one-at-a-time questioning to prevent requirement gaps.
  • Technical Trade-off Analysis: Evaluating multiple architectural approaches (Option A, B, and C) with detailed pros and cons to select the most efficient solution.
  • MVP Optimization: Applying ruthless prioritization to strip away 'nice-to-have' features and focus strictly on the Minimum Viable Product requirements.
  • Design Documentation: Automatically generating standardized design documents that capture problem statements, technical specs, and alternatives considered for team alignment.
  • Incremental Validation: Breaking down complex system designs into digestible chunks for step-by-step sign-off before moving to the implementation phase.
namebrainstorming
descriptionUse when starting any feature, project, or design work. Guides collaborative design refinement through incremental questioning before any code is written.

Brainstorming

Core Principle

Design before code. Always.

Don't jump into implementation. Tease out the spec through conversation first.

The Brainstorming Process

Step 1: Understand the Goal

Ask clarifying questions:

  • What problem are we solving?
  • Who is the user?
  • What does success look like?
  • What are the constraints?

One question at a time - Don't overwhelm with multiple questions.

Step 2: Explore the Space

  • What are the possible approaches?
  • What are the trade-offs?
  • What similar problems exist?
  • What patterns apply?

Step 3: Propose Alternatives

Always present 2-3 approaches before settling:

## Option A: [Name]
- Pros: ...
- Cons: ...
- Best when: ...

## Option B: [Name]
- Pros: ...
- Cons: ...
- Best when: ...

## Option C: [Name]
- Pros: ...
- Cons: ...
- Best when: ...

**Recommendation:** Option [X] because...

Step 4: Incremental Validation

Present design in digestible chunks:

  • Show one section at a time
  • Get sign-off before moving on
  • Allow for course corrections

Step 5: Document the Design

Save to: docs/plans/YYYY-MM-DD-<topic>-design.md

YAGNI Ruthlessly

During brainstorming, actively remove:

  • Features that "might be nice"
  • Edge cases that "could happen"
  • Abstractions for "future flexibility"
  • Optimizations for "scale we might need"

Ask: "Do we need this for the MVP?"

Question Techniques

Multiple Choice Preferred

Instead of: "How should we handle errors?" Ask: "For error handling, should we: A) Return error codes, B) Throw exceptions, C) Use Result types?"

Constrained Questions

Instead of: "What should the API look like?" Ask: "Should this be REST, GraphQL, or RPC?"

Assumption Surfacing

  • "I'm assuming X. Is that correct?"
  • "This depends on Y. Is that available?"
  • "The constraint seems to be Z. Agreed?"

Output: Design Document

# [Feature Name] Design

## Problem Statement
What problem are we solving?

## Goals
- Goal 1
- Goal 2

## Non-Goals
- Explicitly out of scope item 1
- Explicitly out of scope item 2

## Proposed Solution
Overview of the approach

## Alternatives Considered
Why we didn't choose other approaches

## Technical Design
### Component A
...
### Component B
...

## Open Questions
- Question 1
- Question 2

## Next Steps
1. Step 1
2. Step 2

Transition to Implementation

After design is approved:

  1. Ask: "Ready to set up for implementation?"
  2. Use using-git-worktrees skill to create isolated workspace
  3. Use writing-plans skill to create detailed implementation plan

Anti-Patterns

Don't Do This

  • Start coding before design is clear
  • Present only one option
  • Ask open-ended questions when specific ones work
  • Skip validation of each section
  • Assume requirements are complete
  • Over-engineer the initial design