# Brainstorming Workflow

Refines rough ideas into conceptual designs through drafting, self-critique, and trade-off surfacing.

## When to Use

**Explicit trigger only.** Use when user:
- Asks to "brainstorm" a concept
- Wants to "explore" or "think through" an idea
- Has a nascent idea not ready for implementation
- Requests interactive design refinement

**Do not use** when user provides clear instructions and expects execution. Most interactions are execution-focused - don't add friction by brainstorming unsolicited.

## Core Principles

1. **Draft first, ask later.** Don't pepper the user with questions. Use your judgment to draft, then surface gaps.

2. **Conceptual, not implementation.** Output is design decisions and constraints. The implementing AI decides HOW.

3. **Always checkpoint.** Write a defer file after critique. User can leave or continue - nothing is lost.

4. **Subagents for execution.** If continuing to implementation, dispatch subagents. Keep main thread focused on coordination.

## Workflow

### Phase 1: Understand Intent

Quickly gather context:
- What problem does this solve?
- Who/what consumes it?
- What constraints exist?

If context is clear from the user's input, skip questions. If ambiguous, ask 1-2 clarifying questions max - don't interrogate.

Check domain hooks in `domain-hooks.md` for architect-specific questions.

### Phase 2: Draft Conceptual Design

Generate a complete conceptual draft:
- Purpose and scope
- Key design decisions
- Structure/architecture (conceptual, not file-by-file)
- Constraints and boundaries
- What it explicitly does NOT do

**Adapt scope to input clarity:**
- Nascent idea → high-level design, major decision points
- Clear concept → fuller design with more specifics
- Near-implementation ready → detailed design, edge cases

### Phase 3: Self-Critique

Before showing the user, critique your draft against:
- Alignment with stated intent
- Domain anti-patterns (see `domain-hooks.md`)
- Missing pieces or unstated assumptions
- Over-engineering or unnecessary complexity

Note issues found. Revise draft if issues are clear fixes. Flag trade-offs that need user input.

### Phase 4: Present & Checkpoint

Present the design to the user. Then immediately write a defer file (see `../defer-work/workflow.md`) containing:
- The conceptual design
- Trade-offs requiring decisions
- Issues found during critique
- Tasks to move toward implementation

Tell the user:

```
Design captured to .claude/deferred/YYYY-MM-DD-<topic>.md

Trade-offs to decide:
- <trade-off 1>
- <trade-off 2>

You can:
- Clear context and resume later with "pick up <topic>"
- Continue here - I'll work from the checkpoint

What would you like to do?
```

### Phase 5: Resolution (if continuing)

If user continues:
1. Work through trade-offs with user
2. Update defer file with decisions
3. Use subagents to execute tasks from the defer file
4. Subagents check off tasks as they complete
5. Main thread coordinates, delegates execution

## Output Format

The brainstorming output is a **conceptual design**, not a specification. Example structure:

```markdown
## Purpose
<What this solves, in one paragraph>

## Design Decisions
- <Decision 1>: <choice and why>
- <Decision 2>: ...

## Structure
<Conceptual architecture - components, relationships, boundaries>

## Constraints
- <What this must do>
- <What this must NOT do>

## Open Questions
- <Questions that surfaced during drafting>
```

Keep it scannable. User should understand the design in 60 seconds.