Executes tasks from a track's implementation plan using Superpowers' TDD workflow and subagent-driven development. Use when ready to implement a track that has an approved spec and plan.
Execute a track's plan using Superpowers' execution engine (subagent-driven or inline), with track progress management and phase checkpoints.
Copy this checklist and track your progress:
Implementation Progress:
- [ ] Pre-flight: verify project initialized
- [ ] Track selection (argument or interactive)
- [ ] Context loading
- [ ] Track status → in-progress
- [ ] Execution mode selection
- [ ] Per-task loop: RED → GREEN → REFACTOR → commit → mark complete
- [ ] Phase review: code simplifier → code reviewer → auto-fix → INBOX
- [ ] Phase checkpoint → user approval
- [ ] (repeat tasks/phases)
- [ ] Track completion: final verification + status update
If argument provided: validate conductor/tracks/{argument}/plan.md exists.
If no argument: read conductor/tracks.md, show incomplete tracks:
Select a track to implement:
In Progress:
1. [~] auth_20260403 - User Authentication (Phase 2, Task 3)
Pending:
2. [ ] nav-fix_20260402 - Navigation Bug Fix
Enter number or track ID:
Read all relevant context:
conductor/tracks/{trackId}/spec.md — requirementsconductor/tracks/{trackId}/plan.md — task listconductor/tracks/{trackId}/metadata.json — progress stateconductor/product.md — product contextconductor/tech-stack.md — technical constraintsconductor/workflow.md — process rulesconductor/code_styleguides/ — language conventionsMark track as in-progress:
conductor/tracks.md: change [ ] to [~]status: "in_progress", update timestampDetect Superpowers availability using the procedure in docs/detecting-optional-skills.md: check system-reminder skill list, then .claude/settings.json enabledPlugins for superpowers@superpowers-marketplace, then .claude/skills/ for project-scoped installs. The skill is available if any signal is positive. Check for both subagent-driven-development and executing-plans (in either plugin-prefixed or bare form).
If Superpowers is available, offer the choice:
How should this track be implemented?
1. Subagent-driven (recommended) — fresh subagent per task with two-stage review
2. Inline execution — single session, batch checkpoints every 3 tasks
Invoke the subagent-driven-development skill using the Skill tool, passing the track's plan from conductor/tracks/{trackId}/plan.md.
Superpowers handles:
Our wrapper responsibilities (before/after Superpowers runs each task):
Before dispatching each task's subagent, update metadata.json: set current_task to this task's ID (e.g., "2.3") and current_phase to the containing phase number. This ensures resume state is accurate even if the session is interrupted mid-task.
After each task completes, update track metadata:
[x] in conductor/tracks/{trackId}/plan.mdtasks.completed in metadata.jsoncurrent_task to the next incomplete task IDSuperpowers output control: When invoking the skill, instruct it that all artifacts belong in conductor/tracks/{trackId}/ — not docs/superpowers/. If Superpowers writes artifacts outside the track directory despite the instruction, move them in. If Superpowers invokes finishing-a-development-branch at the end, defer to our own Track Completion flow below instead — we manage the track lifecycle, not Superpowers.
Detect availability using the detection procedure: check system-reminder, project settings, and project skills directory for executing-plans. If no signal is positive, fall back to the no-Superpowers path below.
Invoke the executing-plans skill using the Skill tool, passing the track's plan.
Same metadata lifecycle: write current_task before each task starts, update counters after each task completes. Same output control: instruct Superpowers to write to the track directory, redirect anything that escapes, and handle completion via our Track Completion flow.
Execute tasks directly following TDD workflow from conductor/workflow.md:
For each incomplete task ([ ] in plan.md):
[ ] to [~] in plan.mdcurrent_task to this task's ID (e.g., "2.3"), set current_phase to the containing phase number[~] to [x] in plan.md, increment tasks.completed in metadata.jsonAfter all tasks in a phase are [x]:
Build the list of files this phase touched:
Primary method: Collect all "files to modify" entries from the phase's tasks in plan.md.
Fallback (always run as supplement): The plan.md list misses new files created during tasks and files touched incidentally. Always supplement with git:
git log (match by task ID or commit message convention from workflow.md)git diff --name-only {parent-sha}..HEADThis is the phase file list — all review and fixes are scoped to ONLY these files.
Launch Agent 1 first, then Agent 2 after it finishes. Running sequentially avoids edit conflicts when both agents fix the same file.
Agent 1 — Code Simplifier:
Detect the simplify skill using the multi-signal procedure. If found via any signal, invoke it with the phase file list. Otherwise, launch a general-purpose agent:
Review ONLY the following files from this phase: [phase file list]. Check for: unnecessary complexity, duplicated logic across the phase's files, dead code introduced by this phase, inconsistent patterns between tasks in this phase. For each issue found: state the file, line, and a concrete fix. Apply all fixes directly — do not ask for approval. If you discover issues in files outside the phase file list during your review, do NOT fix them. Return them as a separate out-of-scope list.
Agent 2 — Code Reviewer: Launch after Agent 1 completes so it reviews the already-simplified code:
Review ONLY the following files from this phase: [phase file list]. Check for:
- Security issues (injection, XSS, unvalidated input at boundaries)
- Performance regressions (N+1 queries, unnecessary re-renders, missing indexes)
- Correctness bugs (off-by-one, null handling, race conditions)
- Missing error handling at system boundaries
- Style and cosmetic issues (naming, formatting, dead imports)
For each issue found: state the file, line, severity (critical/warning/nit), and fix.
- In-scope (file is in the phase file list): Apply the fix directly, regardless of severity. Fix everything — critical, warning, and nit.
- Out-of-scope (file is NOT in the phase file list but you noticed an issue while reviewing code that calls into it): Do NOT fix. Return as a separate out-of-scope list.
After both agents finish:
refactor: phase {N} code review fixes). If neither agent made changes, skip the commit.issues/INBOX.md:
- {description} in {file}:{line} ({severity}). Source: phase {N} review of {trackId}.
issues/INBOX.md does not exist, create the issues directory structure first (same as /triage bootstrap).Phase {N} complete.
Results:
- All phase tasks: complete
- Code review: {X} in-scope fixes applied, {Y} out-of-scope issues filed to INBOX
- Tests: passing
- Verification: pass
Review fixes committed: {commit SHA or "none — code was clean"}
INBOX items added: {Y}
Approve to continue to Phase {N+1}?
1. Yes, continue
2. No, there are issues to fix
3. Pause implementation
CRITICAL: Never proceed to the next phase without user approval.
Update metadata.json: increment phases.completed.
If resuming a paused track:
current_task field exists in metadata.json, use it[~] (in-progress), or if none, first task marked [ ] (pending)When all phases and tasks are [x]:
conductor/tracks.md: change [~] to [x]status: "complete"Track Complete: {title}
Phases: {N}/{N}
Tasks: {M}/{M}
Commits: {count}
Tests: all passing
Next: Run /uat-create to generate acceptance testing checklist.