Claude-Code-Workflow/.claude/commands/workflow/brainstorm/auto-parallel.md

name, description, usage, argument-hint, examples, allowed-tools

name	description	usage	argument-hint	examples	allowed-tools
auto-parallel	Parallel brainstorming automation with dynamic role selection and concurrent execution	/workflow:brainstorm:auto-parallel "<topic>"	topic or challenge description	/workflow:brainstorm:auto-parallel "Build real-time collaboration feature" /workflow:brainstorm:auto-parallel "Optimize database performance for millions of users" /workflow:brainstorm:auto-parallel "Implement secure authentication system"	SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)

Workflow Brainstorm Parallel Auto Command

Usage

/workflow:brainstorm:auto-parallel "<topic>"

Role Selection Logic

• Technical & Architecture: architecture|system|performance|database|security → system-architect, data-architect, security-expert, subject-matter-expert
• Product & UX: user|ui|ux|interface|design|product|feature|experience → ui-designer, user-researcher, product-manager, ux-expert, product-owner
• Business & Process: business|process|workflow|cost|innovation|testing → business-analyst, innovation-lead, test-strategist
• Agile & Delivery: agile|sprint|scrum|team|collaboration|delivery → scrum-master, product-owner
• Domain Expertise: domain|standard|compliance|expertise|regulation → subject-matter-expert
• Multi-role: Complex topics automatically select 2-3 complementary roles
• Default: product-manager if no clear match

Template Loading: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/<role-name>.md")) Template Source: .claude/workflows/cli-templates/planning-roles/ Available Roles: data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert

Example:

bash($(cat "~/.claude/workflows/cli-templates/planning-roles/system-architect.md"))
bash($(cat "~/.claude/workflows/cli-templates/planning-roles/ui-designer.md"))

Core Workflow

Structured Topic Processing → Role Analysis → Synthesis

The command follows a structured three-phase approach with dedicated document types:

Phase 1: Framework Generation ⚠️ COMMAND EXECUTION

• Role selection: Auto-select 2-3 roles based on topic keywords (see Role Selection Logic)
• Call artifacts command: Execute /workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,role3}" using SlashCommand tool
• Role-specific framework: Generate framework with sections tailored to selected roles

Phase 2: Role Analysis Execution ⚠️ PARALLEL AGENT ANALYSIS

• Parallel execution: Multiple roles execute simultaneously for faster completion
• Independent agents: Each role gets dedicated conceptual-planning-agent running in parallel
• Shared framework: All roles reference the same topic framework for consistency
• Concurrent generation: Role-specific analysis documents generated simultaneously
• Progress tracking: Parallel agents update progress independently

Phase 3: Synthesis Generation ⚠️ COMMAND EXECUTION

• Call synthesis command: Execute /workflow:brainstorm:synthesis using SlashCommand tool

Implementation Standards

Simplified Command Orchestration ⚠️ STREAMLINED

Auto command coordinates independent specialized commands:

Command Sequence:

1. Role Selection: Auto-select 2-3 relevant roles based on topic keywords
2. Generate Role-Specific Framework: Use SlashCommand to execute /workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,role3}"
3. Parallel Role Analysis: Execute selected role agents in parallel, each reading their specific framework section
4. Generate Synthesis: Use SlashCommand to execute /workflow:brainstorm:synthesis

SlashCommand Integration:

1. artifacts command: Called via SlashCommand tool with --roles parameter for role-specific framework generation
2. role agents: Each agent reads its dedicated section in the role-specific framework
3. synthesis command: Called via SlashCommand tool for final integration with role-targeted insights
4. Command coordination: SlashCommand handles execution and validation

Role Selection Logic:

• Technical: architecture|system|performance|database → system-architect, data-architect, subject-matter-expert
• Product & UX: user|ui|ux|interface|design|product|feature|experience → ui-designer, ux-expert, product-manager, product-owner
• Agile & Delivery: agile|sprint|scrum|team|collaboration|delivery → scrum-master, product-owner
• Domain Expertise: domain|standard|compliance|expertise|regulation → subject-matter-expert
• Auto-select: 2-3 most relevant roles based on topic analysis

Simplified Processing Standards

Core Principles:

1. Minimal preprocessing - Only workflow-session.json and basic role selection
2. Agent autonomy - Agents handle their own context and validation
3. Parallel execution - Multiple agents can work simultaneously
4. Post-processing synthesis - Integration happens after agent completion
5. TodoWrite control - Progress tracking throughout all phases

Implementation Rules:

• Maximum 3 roles: Auto-selected based on simple keyword mapping
• No upfront validation: Agents handle their own context requirements
• Parallel execution: Each agent operates concurrently without dependencies
• Synthesis at end: Integration only after all agents complete

Agent Self-Management (Agents decide their own approach):

• Context gathering: Agents determine what questions to ask
• Template usage: Agents load and apply their own role templates
• Analysis depth: Agents determine appropriate level of detail
• Documentation: Agents create their own file structure and content

Session Management ⚠️ CRITICAL

• ⚡ FIRST ACTION: Check for all .workflow/.active-* markers before role processing
• Multiple sessions support: Different Claude instances can have different active brainstorming sessions
• User selection: If multiple active sessions found, prompt user to select which one to work with
• Auto-session creation: WFS-[topic-slug] only if no active session exists
• Session continuity: MUST use selected active session for all role processing
• Context preservation: Each role's context and agent output stored in session directory
• Session isolation: Each session maintains independent brainstorming state and role assignments

Document Generation

Command Coordination Workflow: artifacts → parallel role analysis → synthesis

Output Structure: Coordinated commands generate framework, role analyses, and synthesis documents as defined in their respective command specifications.

Agent Prompt Templates

Task Agent Invocation Template

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: {role-name} perspective for {topic}

     ## Role Assignment
     **ASSIGNED_ROLE**: {role-name}
     **TOPIC**: {user-provided-topic}
     **OUTPUT_LOCATION**: .workflow/WFS-{topic}/.brainstorming/{role}/

     ## Execution Instructions
     [FLOW_CONTROL]

     ### Flow Control Steps
     **AGENT RESPONSIBILITY**: Execute these pre_analysis steps sequentially with context accumulation:

     1. **load_topic_framework**
        - Action: Load structured topic discussion framework
        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/topic-framework.md 2>/dev/null || echo 'Topic framework not found')
        - Output: topic_framework

     2. **load_role_template**
        - Action: Load {role-name} planning template
        - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
        - Output: role_template

     3. **load_session_metadata**
        - Action: Load session metadata and topic description
        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/workflow-session.json 2>/dev/null || echo '{}')
        - Output: session_metadata

     ### Implementation Context
     **Topic Framework**: Use loaded topic-framework.md for structured analysis
     **Role Focus**: {role-name} domain expertise and perspective
     **Analysis Type**: Address framework discussion points from role perspective
     **Template Framework**: Combine role template with topic framework structure
     **Structured Approach**: Create analysis.md addressing all topic framework points

     ### Session Context
     **Workflow Directory**: .workflow/WFS-{topic}/.brainstorming/
     **Output Directory**: .workflow/WFS-{topic}/.brainstorming/{role}/
     **Session JSON**: .workflow/WFS-{topic}/.brainstorming/workflow-session.json

     ### Dependencies & Context
     **Topic**: {user-provided-topic}
     **Role Template**: "~/.claude/workflows/cli-templates/planning-roles/{role}.md"
     **User Requirements**: To be gathered through interactive questioning

     ## Completion Requirements
     1. Execute all flow control steps in sequence (load topic framework, role template, session metadata)
     2. **Address Topic Framework**: Respond to all discussion points in topic-framework.md from role perspective
     3. Apply role template guidelines within topic framework structure
     4. Generate structured role analysis addressing framework points
     5. Create single comprehensive deliverable in OUTPUT_LOCATION:
        - analysis.md (structured analysis addressing all topic framework points with role-specific insights)
     6. Include framework reference: @../topic-framework.md in analysis.md
     7. Update workflow-session.json with completion status",
     description="Execute {role-name} brainstorming analysis")

Parallel Role Agent调用示例

# Execute multiple roles in parallel using single message with multiple Task calls
Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: system-architect perspective for {topic}...",
     description="Execute system-architect brainstorming analysis")

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: ui-designer perspective for {topic}...",
     description="Execute ui-designer brainstorming analysis")

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: security-expert perspective for {topic}...",
     description="Execute security-expert brainstorming analysis")

Direct Synthesis Process (Command-Driven)

Synthesis execution: Use SlashCommand to execute /workflow:brainstorm:synthesis after role completion

TodoWrite Control Flow ⚠️ CRITICAL

Workflow Progress Tracking

MANDATORY: Use Claude Code's built-in TodoWrite tool throughout entire brainstorming workflow:

// Phase 1: Create initial todo list for command-coordinated brainstorming workflow
TodoWrite({
  todos: [
    {
      content: "Initialize brainstorming session and detect active sessions",
      status: "pending",
      activeForm: "Initializing brainstorming session"
    },
    {
      content: "Select roles based on topic keyword analysis",
      status: "pending",
      activeForm: "Selecting roles for brainstorming analysis"
    },
    {
      content: "Execute artifacts command with selected roles for role-specific framework",
      status: "pending",
      activeForm: "Generating role-specific topic framework"
    },
    {
      content: "Execute [role-1] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
      status: "pending",
      activeForm: "Executing [role-1] structured framework analysis"
    },
    {
      content: "Execute [role-2] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
      status: "pending",
      activeForm: "Executing [role-2] structured framework analysis"
    },
    {
      content: "Execute synthesis command using SlashCommand for final integration",
      status: "pending",
      activeForm: "Executing synthesis command for integrated analysis"
    }
  ]
});

// Phase 2: Update status as workflow progresses - ONLY ONE task should be in_progress at a time
TodoWrite({
  todos: [
    {
      content: "Initialize brainstorming session and detect active sessions",
      status: "completed",  // Mark completed preprocessing
      activeForm: "Initializing brainstorming session"
    },
    {
      content: "Select roles for topic analysis and create workflow-session.json",
      status: "in_progress",  // Mark current task as in_progress
      activeForm: "Selecting roles and creating session metadata"
    },
    // ... other tasks remain pending
  ]
});

// Phase 3: Parallel agent execution tracking
TodoWrite({
  todos: [
    // ... previous completed tasks
    {
      content: "Execute system-architect analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing system-architect brainstorming analysis"
    },
    {
      content: "Execute ui-designer analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing ui-designer brainstorming analysis"
    },
    {
      content: "Execute security-expert analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing security-expert brainstorming analysis"
    }
  ]
});

TodoWrite Integration Rules:

1. Create initial todos: All workflow phases at start
2. Mark in_progress: Multiple parallel tasks can be in_progress simultaneously
3. Update immediately: After each task completion
4. Track agent execution: Include [agent-type] and [FLOW_CONTROL] markers for parallel agents
5. Final synthesis: Mark synthesis as in_progress only after all parallel agents complete

Reference Information

Structured Processing Schema

Each role processing follows structured framework pattern:

• topic_framework: Structured discussion framework document
• role: Selected planning role name with framework reference
• agent: Dedicated conceptual-planning-agent instance
• structured_analysis: Agent addresses all framework discussion points
• output: Role-specific analysis.md addressing topic framework structure

File Structure Reference

Architecture: @/.claude/workflows/workflow-architecture.md Role Templates: @/.claude/workflows/cli-templates/planning-roles/

Execution Integration

Command coordination model: artifacts command → parallel role analysis → synthesis command

Error Handling

• Role selection failure: Default to product-manager with explanation
• Agent execution failure: Agent-specific retry with minimal dependencies
• Template loading issues: Agent handles graceful degradation
• Synthesis conflicts: Synthesis agent highlights disagreements without resolution

Quality Standards

Agent Autonomy Excellence

• Single role focus: Each agent handles exactly one role independently
• Self-contained execution: Agent manages own context, validation, and output
• Parallel processing: Multiple agents can execute simultaneously
• Complete ownership: Agent produces entire role-specific analysis package

Minimal Coordination Excellence

• Lightweight handoff: Only topic and role assignment provided
• Agent self-management: Agents handle their own workflow and validation
• Concurrent operation: No inter-agent dependencies enabling parallel execution
• Reference-based synthesis: Post-processing integration without content duplication
• TodoWrite orchestration: Progress tracking and workflow control throughout entire process