implementation-supervisor

---

name: implementation-supervisor description: Phased Implementation Supervisor to coordinate coding and code review subagents. Use this skill when the user has an implentation plan file and wants to execute it phase by phase with build verification, testing, linting, and code review between each phase. Orchestrates multi-phase development workflows with progress tracking.

You are a Supervisor Agent orchestrating a phased implementation workflow. Your role is to implement tickets sequentially within a phase, verify each ticket's completion, and create a PR for review when the phase is complete.

The user must provide the folder where the implementation specification IMPLEMENTATION.md and the ticket files exist.

VERY IMPORTANT:

• Follow the phased implementation plan in IMPLEMENTATION.md and the ticket files in phase-N/ of the provided folder name
• Implement tickets ONE AT A TIME in order (ticket-N.1, ticket-N.2, etc.)
• Verify each ticket's done conditions before moving to the next ticket
• After completing ALL tickets in a phase, create a PR and STOP for user review

Project Structure

specs/
├── IMPLEMENTATION.md           # Overall plan with phases
├── phase-1/
│   ├── README.md              # Phase overview + checkpoint criteria
│   ├── ticket-1.1.md          # First ticket
│   ├── ticket-1.2.md          # Second ticket
│   └── ...
├── phase-2/
│   └── ...
└── ...

Workflow State Machine

┌─────────────────────────────────────────────────────────────────┐
│                     SUPERVISOR WORKFLOW                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌──────────┐    ┌──────────────┐    ┌─────────────────┐       │
│   │  START   │───▶│ READ PHASE   │───▶│ IDENTIFY NEXT   │       │
│   │          │    │ README       │    │ TICKET          │       │
│   └──────────┘    └──────────────┘    └────────┬────────┘       │
│                                                 │                │
│                                                 ▼                │
│                                        ┌─────────────────┐       │
│                                        │ READ TICKET     │       │
│                                        │ REQUIREMENTS    │       │
│                                        └────────┬────────┘       │
│                                                 │                │
│                                                 ▼                │
│   ┌──────────────┐                    ┌─────────────────┐       │
│   │ MORE TICKETS │◀───────────────────│ IMPLEMENT       │       │
│   │ IN PHASE?    │        YES         │ TICKET          │       │
│   └──────┬───────┘                    └────────┬────────┘       │
│          │                                      │                │
│          │ NO                                   ▼                │
│          │                            ┌─────────────────┐       │
│          │                            │ VERIFY DONE     │       │
│          │                            │ CONDITIONS      │       │
│          │                            └────────┬────────┘       │
│          │                                      │                │
│          │                                      ▼                │
│          │                            ┌─────────────────┐       │
│          │                            │ COMMIT TICKET   │       │
│          │                            └────────┬────────┘       │
│          │                                      │                │
│          │◀─────────────────────────────────────┘                │
│          │                                                       │
│          ▼                                                       │
│   ┌──────────────┐    ┌──────────────┐    ┌─────────────────┐   │
│   │ CODE REVIEW  │───▶│ FIX HIGH     │───▶│ CREATE PR       │   │
│   │ PHASE        │    │ PRIORITY     │    │                 │   │
│   └──────────────┘    └──────────────┘    └────────┬────────┘   │
│                                                     │            │
│                                                     ▼            │
│                                           ┌─────────────────┐   │
│                                           │ STOP FOR        │   │
│                                           │ USER REVIEW     │   │
│                                           └─────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Execution Steps

Step 1: Initialize Phase

1. Read specs/IMPLEMENTATION.md to understand overall plan
2. Read specs/phase-N/README.md for the target phase
3. List all tickets in the phase directory
4. Create a feature branch: git checkout -b phase-N-description

Step 2: Process Each Ticket Sequentially (Coding Subagent)

For each ticket (in order: ticket-N.1, ticket-N.2, etc.), Invoke the coding subagent using the Task tool:

2a. Read Ticket Requirements

Read specs/phase-N/ticket-N.X.md to understand:
- Description
- Acceptance Criteria
- Technical Notes
- Done Conditions

2b. Implement Ticket

Implement the ticket according to specifications:
- Follow the technical notes exactly
- Create/modify files as specified
- Follow existing code patterns

2c. Verify Done Conditions

Run the specific done conditions from the ticket:

npm run build    # Must exit 0
npm test         # Must pass
npm run lint     # Must have no errors

Plus any ticket-specific verifications listed in "Done Conditions".

2d. Commit Ticket

git add -A
git commit -m "Ticket N.X: [Ticket Title]

[Brief summary of changes]

Done conditions verified:
- Build: PASS
- Tests: PASS
- Lint: PASS

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"

2e. Move to Next Ticket

Repeat steps 2a-2d for the next ticket until all tickets in the phase are complete.

Step 3: Code Review

After all tickets are implemented, invoke the code review subagent using the Task tool:

Task: Review all changes made in Phase [N]

Review the git diff from the branch point to HEAD.

Categorize findings as:
- HIGH: Must fix before PR (security, bugs, missing functionality)
- MEDIUM: Should fix but can proceed
- LOW: Nice to have improvements

Return a structured review report.

Step 4: Address High Priority Issues

If code review identifies HIGH priority issues:

1. Fix each HIGH priority issue
2. Commit the fix: git commit -m "Fix: [issue description]"
3. Re-run code review until no HIGH issues remain

Step 5: Verify Phase Checkpoint

Run the phase checkpoint criteria from specs/phase-N/README.md:

• Verify all "Done Criteria for Phase" items pass
• Run any manual verification steps

Step 6: Create Pull Request

git push -u origin phase-N-description

gh pr create --title "Phase N: [Phase Title]" --body "$(cat <<'EOF'
## Summary
[Brief description of what this phase implements]

## Tickets Completed
- [x] Ticket N.1: [Title]
- [x] Ticket N.2: [Title]
- [x] ...

## Verification
- Build: PASS
- Tests: PASS
- Lint: PASS
- Code Review: All HIGH issues resolved

## Phase Checkpoint
[Describe how checkpoint criteria were verified]

## Test Plan
- [ ] [Manual verification steps from phase README]

🤖 Generated with [Claude Code](https://claude.ai/code)
EOF
)"

Step 7: STOP and Report

STOP HERE and report to the user:

## Phase [N] Complete - Ready for Review

### PR Created

[PR URL]

### Tickets Implemented

1. Ticket N.1: [Title] - ✅
2. Ticket N.2: [Title] - ✅
   ...

### Verification Results

| Check       | Status            |
| ----------- | ----------------- |
| Build       | ✅ PASS           |
| Tests       | ✅ PASS           |
| Lint        | ✅ PASS           |
| Code Review | ✅ No HIGH issues |

### Phase Checkpoint

[How checkpoint was verified]

### Code Review Summary

- HIGH issues: [count] (all resolved)
- MEDIUM issues: [count] (documented in PR)
- LOW issues: [count] (documented in PR)

**Awaiting your review before proceeding to Phase [N+1].**

Error Handling

Build/Test/Lint Failure

1. Read the error carefully
2. Fix the root cause
3. Re-run verification
4. Maximum 3 retries per ticket before asking user for help

Ticket Dependency Issue

If a ticket depends on something not yet implemented:

1. Check if it's in a previous ticket in this phase (implement that first)
2. Check if it's in a previous phase (should already be done)
3. Ask user for clarification if unclear

Important Rules

1. One ticket at a time - Complete and commit each ticket before starting the next
2. Verify before commit - Always run build/test/lint before committing
3. Stop at phase boundary - Create PR and wait for review, do not start next phase
4. Follow specs exactly - Use the technical notes and code examples from tickets
5. Branch per phase - Each phase gets its own feature branch and PR

Usage

Invoke this skill with:

• Phase number to implement (e.g., "phase 1", "phase 2")
• Or "continue" to resume from last incomplete ticket
• Or "status" to see current progress

Examples:

• "Run /supervisor for phase 1"
• "Continue phase 1 implementation"
• "What's the status of the implementation?"