name	dispatching-parallel-agents
description	Use when multiple independent tasks can run simultaneously. Enables efficient parallel work execution with specialized agents.

Dispatching Parallel Agents

Core Principle

When tasks are independent and can run simultaneously, dispatch multiple agents in parallel rather than sequentially. This maximizes efficiency and reduces total time to completion.

When to Use This Skill

Multiple independent features to implement
Separate bugs to fix that don't interact
Different components that can be worked on simultaneously
Code review and testing can happen in parallel
Documentation and implementation don't block each other

The Iron Law

Only parallelize TRULY INDEPENDENT tasks.

Dependent tasks MUST run sequentially, or you'll create conflicts and waste time.

Identifying Parallelizable Work

✅ Good Candidates for Parallel Execution

Independent features: Authentication and payment system
Separate components: Frontend and backend work
Different skill domains: Code review while writing docs
Non-overlapping files: Different controllers, models, views
Isolated bug fixes: Login bug and API bug

❌ Bad Candidates (Must Be Sequential)

Dependent features: Database migration then seeder (seeder needs migration)
Same files: Two changes to same controller
Build dependencies: Tests need code to be written first
Data dependencies: Need user model before user controller

Dependency Analysis Checklist

Before parallelizing, ask:

Do these tasks touch the same files?
Does Task B need Task A's results?
Will these tasks create merge conflicts?
Are there shared resources (database, cache, files)?
Can these tasks be independently tested?

If ANY answer is YES → Do NOT parallelize

Parallel Agent Dispatch Protocol

Step 1: Identify Independent Tasks

I'm analyzing which tasks can run in parallel.

Task List:
1. Implement authentication (AuthController, User model, routes)
2. Implement payment processing (PaymentController, Payment model, routes)
3. Create API documentation (swagger/openapi)
4. Set up email notifications (NotificationService)

Dependency Analysis:
- Authentication: touches auth files only ✅
- Payment: touches payment files only ✅
- API docs: reads code, doesn't modify ✅
- Email: touches notification files only ✅

All tasks are independent → Can parallelize ✅

Step 2: Plan Agent Assignments

Parallel Agent Plan:

Agent 1: Authentication Implementation
- Files: AuthController, User model, routes/api.php (auth section)
- Skills: brainstorming, writing-plans, executing-plans, test-driven-development
- Estimated time: 60 minutes

Agent 2: Payment Processing Implementation
- Files: PaymentController, Payment model, routes/api.php (payment section)
- Skills: brainstorming, writing-plans, executing-plans, test-driven-development
- Estimated time: 90 minutes

Agent 3: API Documentation Generation
- Files: API docs (generated), PHPDoc comments
- Skills: API documentation generation
- Estimated time: 30 minutes

Agent 4: Email Notification Setup
- Files: NotificationService, email templates
- Skills: writing-plans, executing-plans
- Estimated time: 45 minutes

Expected total time: 90 minutes (longest agent)
Sequential time would be: 225 minutes (60+90+30+45)
Time saved: 135 minutes (60% reduction)

Step 3: Dispatch Agents

IMPORTANT: Use Claude Code's parallel tool invocation

Dispatching 4 agents in parallel:

[Invoke all 4 Task tools simultaneously in a single message]

Example tool invocations:

Task 1: Implement authentication
Task 2: Implement payment processing
Task 3: Generate API documentation
Task 4: Set up email notifications

Step 4: Monitor Progress

Parallel Agent Status:

Agent 1 (Auth): ✅ Completed in 58 minutes
Agent 2 (Payment): 🔄 In progress (Task 4 of 6)
Agent 3 (API Docs): ✅ Completed in 25 minutes
Agent 4 (Email): ✅ Completed in 42 minutes

Waiting for Agent 2 to complete...

Step 5: Integrate Results

All agents completed. Integrating results:

Agent 1 (Auth):
- ✅ AuthController created with tests
- ✅ User model with authentication
- ✅ Routes added to api.php
- ✅ 12 tests, all passing

Agent 2 (Payment):
- ✅ PaymentController created with tests
- ✅ Payment model with Stripe integration
- ✅ Routes added to api.php
- ✅ 18 tests, all passing

Agent 3 (API Docs):
- ✅ OpenAPI documentation generated
- ✅ All endpoints documented
- ✅ Available at /docs/api

Agent 4 (Email):
- ✅ NotificationService created
- ✅ Email templates for auth events
- ✅ Queue configuration
- ✅ 5 tests, all passing

Integration Check:
- Merge conflicts? Checking...
- ✅ No conflicts (agents worked on independent files)
- ✅ All tests still pass after merge
- ✅ API docs include all endpoints

Using Git Worktrees with Parallel Agents

For maximum isolation, combine with git-worktrees skill:

# Create worktrees for each agent
git worktree add -b feature/authentication ../myapp-auth main
git worktree add -b feature/payment ../myapp-payment main
git worktree add -b feature/email ../myapp-email main

# Dispatch agents to work in separate worktrees
# Agent 1 works in ../myapp-auth
# Agent 2 works in ../myapp-payment
# Agent 3 works in ../myapp-email

# After completion, merge one by one
git checkout main
git merge feature/authentication
git merge feature/payment
git merge feature/email

# Clean up worktrees
git worktree remove ../myapp-auth
git worktree remove ../myapp-payment
git worktree remove ../myapp-email

Parallel Testing Strategy

When parallelizing implementation, parallel testing is critical:

Testing Strategy for Parallel Work:

Each agent MUST:
1. Use database-backup skill before tests
2. Use separate test databases (if possible)
3. Run tests in isolation
4. Report test results independently

Test Database Isolation:
- Agent 1: DB_DATABASE=testing_auth
- Agent 2: DB_DATABASE=testing_payment
- Agent 3: No database (docs only)
- Agent 4: DB_DATABASE=testing_email

After all agents complete:
- Run full integration test suite
- Verify no conflicts or regressions

Examples

Example 1: Microservices Development

Task: Create two independent microservices

Parallel Plan:
Agent 1: User Service
- CRUD operations for users
- Authentication
- Independent database

Agent 2: Order Service
- CRUD operations for orders
- Independent database
- No dependency on User Service yet

These are perfect for parallel work:
- Different codebases
- Different databases
- No shared code
- Can be tested independently

Dispatch agents in parallel → Save 50% time

Example 2: Frontend + Backend Split

Task: Add user profile feature

Parallel Plan:
Agent 1: Backend API
- ProfileController with GET/PUT endpoints
- Profile model
- Validation
- Tests
Files: backend/app/Http/Controllers/ProfileController.php, etc.

Agent 2: Frontend UI
- Profile page component
- API integration
- Form validation
- Tests
Files: frontend/src/components/Profile.tsx, etc.

Independence check:
✅ Different directories (backend/ vs frontend/)
✅ Can work on API contract simultaneously
✅ Can test independently (mock API for frontend)

Dispatch agents in parallel → Complete in single timeframe

Example 3: Bug Fixes

Task: Fix multiple unrelated bugs

Parallel Plan:
Agent 1: Login validation bug
Files: AuthController.php, LoginRequest.php
Tests: AuthenticationTest.php

Agent 2: API rate limiting bug
Files: RateLimitMiddleware.php
Tests: RateLimitTest.php

Agent 3: Email template bug
Files: WelcomeEmail.php, welcome.blade.php
Tests: EmailTest.php

Independence check:
✅ Different files
✅ No shared dependencies
✅ Can be tested independently

Dispatch 3 agents in parallel → 3x faster completion

Red Flags (Don't Parallelize)

❌ Tasks touch same files
❌ Task B needs Task A's output
❌ Shared database without isolation
❌ Changes to same API endpoints
❌ Modifying same configuration files
❌ Creating same migrations
❌ Not enough information to ensure independence

Common Rationalizations to Reject

❌ "They're probably independent" → KNOW they're independent
❌ "We can fix conflicts later" → Avoid conflicts by not parallelizing
❌ "Parallelizing will be faster" → Only if truly independent
❌ "Let's try and see" → Analyze dependencies first

When Parallelization Goes Wrong

If you dispatch parallel agents and encounter issues:

❌ Parallel Agent Conflict Detected

Agent 1 and Agent 2 both modified: routes/api.php

Conflict:
Agent 1 added auth routes
Agent 2 added payment routes
Same file, merge conflict

Resolution:
1. Stop remaining agents
2. Manually merge changes
3. Re-run tests
4. Lesson: Should have split routes/api.php by concern first

Prevention:
- Better dependency analysis
- Split shared files first
- Use more granular tasks

Integration with Skills

Prerequisites:

brainstorming - Identify all work
writing-plans - Break into tasks
Dependency analysis

Use with:

git-worktrees - Isolate work in separate directories
executing-plans - Each agent executes its plan
code-review - Parallel reviews possible

After completion:

code-review - Review integrated result
verification-before-completion - Full system test

Parallel Agent Checklist

Before dispatching parallel agents:

Tasks are truly independent (no shared files)
No dependencies between tasks
Each task can be tested independently
Database isolation configured (if needed)
Clear agent assignments and responsibilities
Estimated time for each agent
Plan for integrating results

During parallel execution:

Monitor agent progress
Watch for unexpected conflicts
Ready to intervene if issues arise

After completion:

Integrate results from all agents
Check for merge conflicts
Run full integration tests
Verify nothing broken

Authority

This skill is based on:

Software engineering: Parallel development practices
Efficiency: Reduce total completion time
Resource utilization: Multiple AI agents available
Professional teams: How large teams work in parallel

Social Proof: Large tech companies have hundreds of developers working in parallel on independent features.

Your Commitment