Executing Work in Parallel

Core Pattern

Parallel execution prevents context saturation and accelerates work through concurrent processing. Key principle: implement shared dependencies first, then launch independent agents simultaneously.

When to parallelize

• •2+ independent tasks — Different files or modules without interactions
• •Research investigations — Multiple agents exploring different aspects
• •Layer-based work — Database → API → Frontend stages
• •Multi-file refactoring — Changes without interdependencies

When NOT to parallelize

• •Single file modification — Use direct tools
• •Sequential operations — Tasks building on each other
• •Shared resource conflicts — Multiple agents modifying same file
• •Complex interdependencies — Most tasks depend on others

Execution Framework

Phase 1: Task Analysis

1. •Map all tasks — Comprehensive list of everything needed
2. •Identify dependencies — Document what depends on what
3. •Group independent work — Find tasks running simultaneously
4. •Validate groupings — Confirm groups are truly independent

Phase 2: Implementation

Step 1: Shared Dependencies Implement first alone (shared types, interfaces, schemas, core utilities). Never parallelize these—they block other work.

Step 2: Parallel Execution Use single function_calls block with multiple Task invocations:

<function_calls>
  <invoke name="Task">
    <parameter name="description">First parallel task</parameter>
    <parameter name="subagent_type">appropriate-agent</parameter>
    <parameter name="prompt">Detailed context and instructions...</parameter>
  </invoke>
  <invoke name="Task">
    <parameter name="description">Second parallel task</parameter>
    <parameter name="subagent_type">appropriate-agent</parameter>
    <parameter name="prompt">Detailed context and instructions...</parameter>
  </invoke>
</function_calls>

Step 3: Wait and Reassess Let agents complete, then:

• •Review results
• •Identify newly unblocked work
• •Plan next batch

Step 4: Repeat Continue batching until complete.

Common Patterns

Layer-Based

Stage 1: Database schema + Type definitions + Core utilities
Stage 2: Service layer + API endpoints + Frontend components
Stage 3: Tests + Documentation + Configuration

Feature-Based

Stage 1: Independent feature implementations
Stage 2: Integration points between features
Stage 3: Cross-cutting concerns

Research-First

Stage 1: Multiple research agents investigating aspects
Stage 2: Consolidation and planning from findings
Stage 3: Parallel implementation of requirements

Agent Delegation Checklist

✅ Provide complete context

• •Exact file paths to read for patterns
• •Target files to modify
• •Existing conventions to follow
• •Expected output format

✅ Use appropriate agents

• •programmer — API, services, data layers, components, pages, styling
• •Explore — Semantic searches, flow tracing
• •senior-engineer — Testing and verification
• •orchestrator — Complex multi-agent work

✅ Respect dependencies

• •Type dependencies (interfaces others use)
• •Core utilities and shared functions
• •Database schemas and migrations
• •API contracts and payloads
• •Never parallelize dependent tasks

Thresholds

Critical Reminders

1. •Implement shared dependencies alone first — Types, interfaces, schemas, base utilities
2. •Single function_calls block per batch — All parallel invocations in one call
3. •Exact file paths — Agents need explicit guidance
4. •Think between batches — Reassess what's unblocked after each stage
5. •Monitor context limits — Split complex tasks rather than overload agents
6. •Quality over speed — Correctness and correctness always supersede parallelization