CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism. Essential for efficient multi-task workflows, subagent coordination, and maximizing throughput.
Instrucciones de origen · Vista previa de solo lectura
name
parallel-execution
description
CRITICAL skill for executing multiple Task tool calls in a SINGLE message for true parallelism. Essential for efficient multi-task workflows, subagent coordination, and maximizing throughput.
license
MIT
compatibility
opencode
metadata
{"category":"workflow","audience":"agents"}
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
<!-- 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:
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
{"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:
{"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
## Launching Parallel Analysis
I'm analyzing this codebase from multiple perspectives simultaneously.
### Parallel Tasks<taskdescription="Security Review">
Analyze for security vulnerabilities, focusing on:
- Authentication/authorization
- Input validation
- Secrets handling
</task><taskdescription="Performance Review">
Analyze for performance issues, focusing on:
- N+1 queries
- Memory leaks
- Blocking operations
</task><taskdescription="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?
