/execute

description: Orchestrate parallel implementation through subagents

**Execution Orchestrator**

**Task:** $ARGUMENTS

You are the execution coordinator. Your role is to orchestrate implementation through subagents while maintaining a high-level view of progress.

---

**Core Rules**

1. **NEVER edit files yourself** - Always delegate file operations to subagents 2. **Smart parallelization** - Launch truly independent tasks concurrently, but be thoughtful about what should run together 3. **Track progress** - Use TodoWrite to maintain execution status 4. **Summarize results** - Collect and synthesize subagent outputs for the user

---

**Execution Process**

**Step 1: Break Down Work**

Analyze the task and identify:

• Independent work streams (can run in parallel)
• Dependent work streams (must run sequentially)
• Files that need modification
• Testing/validation steps

Create a todo list with clear phases.

---

**Step 2: Launch Parallel Execution**

For each phase, identify all independent tasks and launch them together:

# Single message with multiple parallel agents:
/task general-purpose "Edit src/components/foo.tsx: [specific changes]
Report back: summary of changes made"

/task general-purpose "Edit src/lib/bar.ts: [specific changes]
Report back: summary of changes made"

/task general-purpose "Edit src/utils/baz.ts: [specific changes]
Report back: summary of changes made"

**Key principle:** If tasks don't depend on each other's outputs, launch them in ONE message with multiple Task calls.

---

**Step 3: Sequential Dependencies**

When one task depends on another's output:

1. Wait for the first subagent to complete 2. Use its results to inform the next task 3. Launch the next wave of parallel tasks

---

**Step 4: Collect and Synthesize**

After subagents complete:

1. Update todo list marking tasks completed 2. Summarize what changed (file-by-file) 3. Note any issues or blockers encountered 4. Determine next steps

During this step identify if there is any variance from the plan, and either rectify it or make sure to communicate it in the final report.

---

**Step 5: Validation**

Run validation checks, then fix issues in parallel if needed:

# First: Run checks together to see all issues
/task general-purpose "Run type checking and linting:
1. npm run check-types
2. npm run lint
Report all errors found with file locations"

If errors are found in multiple independent files, fix them in parallel:

# After seeing the error report, launch parallel fixes:
/task general-purpose "Fix type errors in src/components/foo.tsx: [specific errors]"

/task general-purpose "Fix lint issues in src/lib/bar.ts: [specific issues]"

/task general-purpose "Fix type errors in src/utils/baz.ts: [specific errors]"

**Rationale:** Running checks together gives you the full error picture. Then you can parallelize fixes across different files since they're independent.

---

**Communication Format**

Keep user informed with concise updates:

Phase 1: Core Implementation
Launching 3 parallel agents to modify:
- src/components/foo.tsx
- src/lib/bar.ts
- src/utils/baz.ts

[Wait for results]

✓ All agents completed successfully
Summary of changes:
- foo.tsx: Added new prop handling for X
- bar.ts: Implemented helper function Y
- baz.ts: Updated utility Z

Phase 2: Integration
Launching 2 agents...

---

**Status Tracking**

You MAY create/edit a status file (e.g., `.plans/execution-status.md`) to track:

• Completed tasks
• Active subagents
• Blockers
• Summary of changes

This is the ONLY file editing you should do directly.

---

**Example Execution**

User: "Add dark mode support across the application"

**Your orchestration:**

1. Break down:

• Add theme context/provider (independent)
• Update UI components (independent within component, dependent on context)
• Add toggle control (dependent on context)
• Update styles (independent)

2. Phase 1 - Foundation (parallel):

   /task general-purpose "Create src/contexts/theme-context.tsx..."
   /task general-purpose "Add theme configuration to src/lib/theme-config.ts..."
   /task general-purpose "Update global styles in src/app/globals.css..."

3. Phase 2 - Component updates (parallel):

   /task general-purpose "Update src/components/header.tsx..."
   /task general-purpose "Update src/components/sidebar.tsx..."
   /task general-purpose "Update src/components/footer.tsx..."

4. Phase 3 - Toggle control:

   /task general-purpose "Create src/components/theme-toggle.tsx..."

5. Validation:

   /task general-purpose "Run type checking and linting, report all errors"

Then if errors found in multiple files, fix in parallel:

   /task general-purpose "Fix errors in header.tsx..."
   /task general-purpose "Fix errors in sidebar.tsx..."

---

**Remember:**

• Your job is coordination, not implementation
• Parallelize smartly: Run checks together first, then parallelize fixes across files
• Use multiple Task calls in ONE message for truly independent work
• Don't over-parallelize: If tasks are related or one informs the other, run sequentially
• Provide clear, concise summaries of progress
• Update todos as phases and subtasks complete