---
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

## Overview

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 in small sections (200-300 words), checking after each section whether it looks right so far.

## The Process

**Understanding the idea:**
- Check out the current project state first (files, docs, recent commits)
- Ask questions one at a time to refine the idea
- Prefer multiple choice questions when possible, but open-ended is fine too
- Only one question per message - if a topic needs more exploration, break it into multiple questions
- Focus on understanding: purpose, constraints, success criteria

**Exploring approaches:**
- Propose 2-3 different approaches with trade-offs
- Present options conversationally with your recommendation and reasoning
- Lead with your recommended option and explain why

**Presenting the design:**
- Once you believe you understand what you're building, present the design
- Break it into sections of 200-300 words
- Ask after each section whether it looks right so far
- Cover: architecture, components, data flow, error handling, testing
- Be ready to go back and clarify if something doesn't make sense

## RalphLoop "Tackle Until Solved" Integration with Complete Pipeline Flow

For complex tasks (estimated 5+ steps), brainstorming automatically delegates to Ralph Orchestrator for autonomous iteration with a complete end-to-end pipeline.

### When Ralph is Triggered

Ralph mode activates for tasks with:
- Architecture/system-level keywords (architecture, platform, framework, multi-tenant, distributed)
- Multiple implementation phases
- Keywords like: complex, complete, production, end-to-end
- Pipeline keywords: complete chain, complete pipeline, real-time logger, automated qa, monitoring agent, ai engineer second opinion
- User opt-in via `RALPH_AUTO=true` or `BRAINSTORMING_USE_RALPH=true`

### Complete Pipeline Flow (Ralph's 5-Phase Process)

Ralph automatically follows this pipeline for complex tasks:

**Phase 1: Investigation & Analysis**
- Thoroughly investigate the issue/codebase
- Identify all root causes with evidence
- Document findings

**Phase 2: Design with AI Engineer Review**
- Propose comprehensive solution
- **MANDATORY**: Get AI Engineer's second opinion BEFORE any coding
- Address all concerns raised
- Only proceed after design approval

**Phase 3: Implementation**
- Follow approved design precisely
- Integrate real-time logging
- Monitor for errors during implementation

**Phase 4: Automated QA**
- Use test-writer-fixer agent with:
  - backend-architect review
  - frontend-developer review
  - ai-engineer double-check
- Fix any issues found

**Phase 5: Real-Time Monitoring**
- Activate monitoring agent
- Catch issues in real-time
- Auto-trigger fixes to prevent repeating errors

### Critical Rules

1. **AI Engineer Review REQUIRED**: Before ANY coding/execution, the AI Engineer agent MUST review and approve the design/approach. This is NON-NEGOTIABLE.

2. **Real-Time Logger**: Integrate comprehensive logging that:
   - Logs all state transitions
   - Tracks API calls and responses
   - Monitors EventBus traffic
   - Alerts on error patterns
   - Provides live debugging capability

3. **Automated QA Pipeline**: After implementation completion:
   - Run test-writer-fixer with backend-architect
   - Run test-writer-fixer with frontend-developer
   - Run test-writer-fixer with ai-engineer for double-check
   - Fix ALL issues found before marking complete

4. **Real-Time Monitoring**: Activate monitoring that:
   - Catches errors in real-time
   - Auto-triggers AI assistant agent on failures
   - Detects and solves issues immediately
   - Prevents repeating the same errors

### Using Ralph Integration

When a complex task is detected:

1. Check for Python integration module:
   ```bash
   python3 /home/uroma/.claude/skills/brainstorming/ralph-integration.py "task description" --test-complexity
   ```

2. If complexity >= 5, delegate to Ralph:
   ```bash
   /home/uroma/obsidian-web-interface/bin/ralphloop "Your complex task here"
   ```

3. Monitor Ralph's progress in `.ralph/state.json`

4. On completion, present Ralph's final output from `.ralph/iterations/final.md`

### Manual Ralph Invocation

For explicit Ralph mode on any task:
```bash
export RALPH_AUTO=true
# or
export BRAINSTORMING_USE_RALPH=true
```

Then invoke `/brainstorming` as normal.

## After the Design

**Documentation:**
- Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
- Use elements-of-style:writing-clearly-and-concisely skill if available
- Commit the design document to git

**Implementation (if continuing):**
- Ask: "Ready to set up for implementation?"
- Use superpowers:using-git-worktrees to create isolated workspace
- Use superpowers:writing-plans to create detailed implementation plan

## Key Principles

- **One question at a time** - Don't overwhelm with multiple questions
- **Multiple choice preferred** - Easier to answer than open-ended when possible
- **YAGNI ruthlessly** - Remove unnecessary features from all designs
- **Explore alternatives** - Always propose 2-3 approaches before settling
- **Incremental validation** - Present design in sections, validate each
- **Be flexible** - Go back and clarify when something doesn't make sense
- **Autonomous iteration** - Delegate complex tasks to Ralph for continuous improvement
- **Complete pipeline flow** - Ralph follows 5 phases: Investigation → Design (AI Engineer review) → Implementation → QA → Monitoring
- **AI Engineer approval** - Design MUST be reviewed by AI Engineer before any coding
- **Real-time logging** - All solutions integrate comprehensive logging for production debugging
- **Automated QA** - All implementations pass test-writer-fixer with backend-architect, frontend-developer, and ai-engineer
- **Real-time monitoring** - Activate monitoring agents to catch and fix issues immediately
