Identify and execute independent operations in parallel for 3-5x speedup. Auto-analyzes task dependencies, groups into batches, launches parallel Task() calls. Applies to /optimize (5 checks), /ship pre-flight (5 checks), /implement (task batching), /prototype (N screens). Auto-triggers when detecting multiple independent operations in a phase.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Identify and execute independent operations in parallel for 3-5x speedup. Auto-analyzes task dependencies, groups into batches, launches parallel Task() calls. Applies to /optimize (5 checks), /ship pre-flight (5 checks), /implement (task batching), /prototype (N screens). Auto-triggers when detecting multiple independent operations in a phase.
The parallel-execution-optimizer skill transforms sequential workflows into concurrent execution patterns, dramatically reducing wall-clock time for phases with multiple independent operations.
/implement processes tasks one-by-one despite no dependencies
Prototype screens generated sequentially when all could run in parallel
This skill analyzes operation dependencies, groups independent work into batches, and orchestrates parallel execution using multiple Task() agent calls in a single message. The result: 3-5x faster phase completion with zero compromise on quality or correctness.
<quick_start>
<basic_pattern>
When you detect multiple independent operations, send a single message with multiple tool calls:
Sequential (slow):
Send message with Task call for security-sentry
Wait for response
Send message with Task call for performance-profiler
Wait for response
Send message with Task call for accessibility-auditor
Total: 15 minutes
Parallel (fast):
Send ONE message with 3 Task calls (security-sentry, performance-profiler, accessibility-auditor)
All three run concurrently
Total: 5 minutes
</basic_pattern>
<immediate_use_cases>
/optimize phase: Run 5 quality checks in parallel (security, performance, accessibility, code-review, type-safety)
**Identify independent operations**
**Analyze dependencies**
**Group into batches**
**Execute parallel batches**
**Aggregate results**
**Context**: Running /optimize on a feature with UI components
**Context**: Running pre-flight checks before deployment
**Context**: 12 tasks with dependency graph in /implement phase
After applying parallel execution optimization:
/ship pre-flight: Run 5 deployment checks in parallel (env-vars, build, docker, CI-config, dependency-audit)
/implement: Process independent task batches in parallel layers
<prototype_screens>
Operation: Generate multiple prototype screens in parallel
Use case: User wants to create 3 different screens (login, dashboard, settings)
Sequential approach (slow):
Generate login screen
Generate dashboard screen
Generate settings screen
Total: 15 minutes
Parallel approach (fast):
Launch 3 screen agents in single message (login, dashboard, settings)
Total: 5 minutes (all generate concurrently)
Speedup: 3x
Note: All screens share theme.yaml for consistency.
</prototype_screens>
</phase_specific_patterns>
<dependency_analysis>
<determining_independence>
Two operations are independent if:
Read-only access to shared resources: Both only read the same files (safe to parallelize)
Disjoint file access: They read/write completely different files
No temporal dependencies: Neither requires the other's output
Idempotent operations: Running them in any order produces same result
Two operations are dependent if:
Write-after-read: Operation B reads file that Operation A writes
Write-after-write: Both write to same file (race condition)
Data dependency: Operation B needs Operation A's output as input
Order-dependent side effects: Operations modify shared state
</determining_independence>
<common_patterns>
Independent (safe to parallelize):
Multiple quality checks reading codebase
Multiple file reads (spec.md, plan.md, tasks.md)
Multiple API documentation fetches
Multiple test suite runs (if isolated)
Multiple lint checks on different file types
Dependent (must sequence):
Generate code → Run tests on generated code
Fetch API docs → Generate client based on docs
Write file → Read file back for validation
Create database schema → Run migrations
Build project → Deploy built artifacts
</common_patterns>
<edge_cases>
Shared mutable state: If operations modify the same git branch, database, or filesystem location, they CANNOT run in parallel safely.
Resource contention: Even if logically independent, operations competing for same resource (CPU, memory, network) may not see speedup. Monitor system resources.
Cascading failures: If one parallel operation fails and others depend on it indirectly, you may need to cancel or retry the batch.
</edge_cases>
</dependency_analysis>
<auto_trigger_conditions>
<when_to_apply>
Automatically apply parallel execution when you detect:
Multiple quality checks: ≥3 independent checks in /optimize or /ship
Multiple file reads: ≥3 files to read that don't depend on each other
Multiple API calls: ≥2 external API documentation fetches
Batch task processing: ≥5 tasks in /implement with identifiable layers
Multiple test suites: Unit, integration, E2E running independently
