Brainstorming & Design

Structured methodology for transforming rough ideas into fully-formed, validated designs through six systematic phases of exploration, refinement, and documentation.

Perfect for developers and architects who need to explore design options methodically before committing to implementation.

Six-Phase Process

Phase Overview

Understanding - Gather purpose, constraints, success criteria
Exploration - Present 2-3 architectural approaches with trade-offs
Design Presentation - Validate design incrementally in digestible sections
Design Documentation - Write findings to docs/plans/YYYY-MM-DD-<topic>-design.md
Worktree Setup - Establish isolated development workspace (optional)
Planning Handoff - Create detailed implementation plan

Phase 1: Understanding

Goal: Gather complete context before proposing solutions

Systematic Questions:

What problem are we solving?
Who are the users/stakeholders?
What are the success criteria?
What constraints exist (time, budget, technical)?
What's already been tried?
What must we preserve?

Use AskUserQuestion Tool:

For decisions with 2-4 distinct options
When choices are mutually exclusive
To ensure explicit user selection

Use Open-Ended Questions:

For feedback and validation
When gathering context
For exploratory discussion

Phase 2: Exploration

Present 2-3 Architectural Approaches:

For Each Approach, Include:

Pros:

Key advantages
What it does well
Alignment with requirements

Cons:

Limitations and drawbacks
What it doesn't solve
Technical debt created

Trade-offs:

Performance vs. simplicity
Flexibility vs. maintainability
Speed-to-market vs. scalability

Example Structure:

MARKDOWN

### Approach A: Microservices Architecture

**Pros:**
- Independent scaling of components
- Technology flexibility per service
- Fault isolation

**Cons:**
- Operational complexity
- Network latency
- Distributed debugging challenges

**Trade-offs:**
- Complexity for scalability
- Dev velocity vs. long-term maintenance

Phase 3: Design Presentation

Incremental Validation:

Present in 200-300 Word Sections:

One concept per section
Wait for user feedback
Adjust based on input
Build consensus incrementally

Don't:

Dump entire design at once
Assume understanding
Skip validation points
Ignore feedback signals

Validation Checkpoints:

After high-level architecture
After each major component
After integration points
Before finalizing

Phase 4: Design Documentation

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

Document Structure:

MARKDOWN

# [Feature/System Name] Design

## Problem Statement
[What we're solving and why]

## Success Criteria
[How we'll know it's working]

## Approach
[Chosen architecture and rationale]

## Components
[Key parts and their responsibilities]

## Trade-offs
[What we're accepting/rejecting and why]

## Implementation Plan
[High-level steps]

## Open Questions
[Unresolved issues to address]

Phase 5: Worktree Setup (Optional)

If Implementing:

Create isolated workspace:

BASH

git worktree add .worktrees/feature-name
cd .worktrees/feature-name

Benefits:

Keep main workspace clean
Parallel development
Easy abandonment if needed
Isolated testing

Phase 6: Planning Handoff

Create Implementation Plan:

Detailed Plan Includes:

Tasks Breakdown:

Ordered implementation steps
Dependencies between tasks
Estimated effort
Testing strategy

Success Metrics:

How to verify each step
Integration testing approach
Acceptance criteria

Risks:

Known challenges
Mitigation strategies
Fallback options

Decision Flowchart

When to Revisit Phases:

New constraint emerges? → Back to Understanding
Trade-off unacceptable? → Back to Exploration
Design not validating? → Back to Design Presentation
Implementation blocked? → Back to Planning

Iteration is Expected: