parallel-execution

# Parallel Execution **CRITICAL**: This skill teaches how to execute multiple tasks simultaneously for maximum efficiency. ## The Fundamental Rule > **ALL Task calls MUST be in a SINGLE assistant message for true parallelism.** If Task calls are in separate messages, they run SEQUENTIALLY, not in parallel. --- ## Why Parallel Execution Matters ### Sequential (SLOW - AVOID) ``` Message 1: Start Task A ↓ wait for completion Message 2: Start Task B ↓ wait for completion Message 3: Start Task C ↓ wait for completion Total time = A + B + C = 90 seconds (if each takes 30s) ``` ### Parallel (FAST - USE THIS) ``` Message 1: Start Task A ─┐ Start Task B ─┼─ All run simultaneously Start Task C ─┘ Total time ≈ max(A, B, C) = 30 seconds ``` **Speedup: 3x faster with 3 parallel tasks** --- ## How to Execute in Parallel ### Step 1: Identify Independent Tasks Tasks are independent when: - They don't depend on each other's output - They don't modify the same files - They can run in any order ### Step 2: Launch ALL Tasks in ONE Message ```xml <!-- CORRECT: All tasks in single message = PARALLEL --> <task> <description>Analyze authentication module</description> <prompt>Review src/auth for security patterns...</prompt> </task> <task> <description>Analyze API layer</description> <prompt>Review src/api for REST best practices...</prompt> </task> <task> <description>Analyze database layer</description> <prompt>Review src/db for query optimization...</prompt> </task> ``` ### Step 3: Collect and Synthesize Results After all tasks complete, combine their findings into a unified response. --- ## Parallelization Patterns ### Pattern 1: Task-Based Parallelization When you have N independent tasks, spawn N subagents: ``` Implementation Plan: 1. Implement auth module 2. Create API endpoints 3. Add database schema 4. Write unit tests 5. Update documentation Launch 5 parallel subagents: ├─ Subagent 1: Implement auth module ├─ Subagent 2: Create API endpoints ├─ Subagent 3: Add database schema ├─ Subagent 4: Write unit tests └─ Subagent 5: Update documentation ``` **All 5 in ONE message!** ### Pattern 2: Directory-Based Parallelization Analyze different directories simultaneously: ``` Codebase Structure: ├── src/auth/ ├── src/api/ ├── src/db/ └── src/ui/ Launch 4 parallel subagents: ├─ Subagent 1: Analyze src/auth ├─ Subagent 2: Analyze src/api ├─ Subagent 3: Analyze src/db └─ Subagent 4: Analyze src/ui ``` ### Pattern 3: Perspective-Based Parallelization Review from multiple angles at once: ``` Code Review Perspectives: - Security vulnerabilities - Performance bottlenecks - Test coverage gaps - Architecture patterns Launch 4 parallel subagents: ├─ Subagent 1: Security review ├─ Subagent 2: Performance analysis ├─ Subagent 3: Test coverage review └─ Subagent 4: Architecture assessment ``` ### Pattern 4: Adversarial Verification Use conflicting mandates for thorough review: ``` Verification Subagents (all parallel): ├─ Syntax & Type Checker ├─ Test Runner ├─ Lint & Style Checker ├─ Security Scanner └─ Build Validator Then (sequential, after above complete): ├─ False Positive Filter ├─ Missing Issues Finder └─ Context Validator ``` --- ## TodoWrite Integration When using parallel execution, mark ALL parallel tasks as `in_progress` simultaneously: ### Before Launching Parallel Tasks ```json { "todos": [ { "content": "Analyze auth module", "status": "in_progress", "activeForm": "Analyzing auth module" }, { "content": "Analyze API layer", "status": "in_progress", "activeForm": "Analyzing API layer" }, { "content": "Analyze database layer", "status": "in_progress", "activeForm": "Analyzing database layer" }, { "content": "Synthesize findings", "status": "pending", "activeForm": "Synthesizing findings" } ] } ``` ### After Each Task Completes Mark as completed as results come in: ```json { "todos": [ { "content": "Analyze auth module", "status": "completed", "activeForm": "Analyzing auth module" }, { "content": "Analyze API layer", "status": "completed", "activeForm": "Analyzing API layer" }, { "content": "Analyze database layer", "status": "in_progress", "activeForm": "Analyzing database layer" }, { "content": "Synthesize findings", "status": "pending", "activeForm": "Synthesizing findings" } ] } ``` --- ## When to Parallelize ### Good Candidates | Scenario | Parallel Approach | |----------|-------------------| | Multiple independent analyses | One subagent per analysis | | Multi-file processing | One subagent per file/directory | | Different review perspectives | One subagent per perspective | | Multiple independent features | One subagent per feature | | Exploratory research | Multiple search strategies | ### When NOT to Parallelize | Scenario | Why Sequential | |----------|----------------| | Tasks with dependencies | B needs A's output | | Same file modifications | Risk of conflicts | | Sequential workflows | Order matters (commit → push → PR) | | Shared state | Race conditions | | Limited resources | Overwhelming the system | --- ## Performance Impact | # Parallel Tasks | Sequential Time | Parallel Time | Speedup | |------------------|-----------------|---------------|---------| | 2 | 60s | 30s | 2x | | 3 | 90s | 30s | 3x | | 5 | 150s | 30s | 5x | | 10 | 300s | 30s | 10x | *Assuming each task takes ~30 seconds* --- ## Common Mistakes ### Mistake 1: Separate Messages ``` WRONG (Sequential): Message 1: "I'll start analyzing the auth module..." <task>Analyze auth</task> Message 2: "Now let me analyze the API..." <task>Analyze API</task> RIGHT (Parallel): Message 1: "I'll analyze all modules in parallel..." <task>Analyze auth</task> <task>Analyze API</task> <task>Analyze DB</task> ``` ### Mistake 2: Announcing Before Acting ``` WRONG: "I'm going to launch three parallel tasks to analyze the codebase." [waits for response] "Now launching the tasks..." RIGHT: "Launching three parallel analysis tasks now:" <task>...</task> <task>...</task> <task>...</task> ``` ### Mistake 3: Forgetting Synthesis ``` WRONG: Just dump all task outputs without integration RIGHT: After receiving all results, synthesize: - Identify common themes - Resolve contradictions - Prioritize findings - Create unified recommendations ``` --- ## Parallel Execution Checklist Before launching parallel tasks, verify: - [ ] Tasks are truly independent - [ ] No shared file modifications - [ ] No sequential dependencies - [ ] All tasks in SINGLE message - [ ] TodoWrite updated with all `in_progress` - [ ] Synthesis step planned --- ## Template: Parallel Analysis ```markdown ## Launching Parallel Analysis I'm analyzing this codebase from multiple perspectives simultaneously. ### Parallel Tasks <task description="Security Review"> Analyze for security vulnerabilities, focusing on: - Authentication/authorization - Input validation - Secrets handling </task> <task description="Performance Review"> Analyze for performance issues, focusing on: - N+1 queries - Memory leaks - Blocking operations </task> <task description="Test Coverage Review"> Analyze test coverage, focusing on: - Missing test cases - Edge cases - Integration tests </task> ### Synthesis (after all complete) [Combine findings into prioritized report] ``` --- ## Quick Reference ``` RULE #1: ALL Task calls in SINGLE message = PARALLEL Task calls in SEPARATE messages = SEQUENTIAL PATTERNS: Task-based: One subagent per task Directory-based: One subagent per directory Perspective-based: One subagent per viewpoint Adversarial: Multiple competing reviewers TODOWRITE: Mark ALL parallel tasks as in_progress BEFORE launching Mark each as completed AFTER receiving results SPEEDUP: N parallel tasks ≈ Nx faster (5 tasks @ 30s each: 150s → 30s) CHECKLIST: ☐ Tasks independent? ☐ No shared files? ☐ No dependencies? ☐ All in ONE message? ☐ Synthesis planned? ```