Implement Plan

---
name: implement-plan
description: Execute an approved implementation plan from the configured plans
  directory. Use when the user wants to implement a plan phase by phase with
  verification.
argument-hint: "[path to plan file]"
allowed-tools:
  - Bash(accelerator config *)
  - Bash(accelerator corpus frontmatter validate *)
---

# Implement Plan

!`accelerator config context --skill implement-plan --fail-safe`
!`accelerator config agents --fail-safe`

If no "Agent Names" section appears above, use these defaults:
accelerator:reviewer, accelerator:codebase-locator,
accelerator:codebase-analyser, accelerator:codebase-pattern-finder,
accelerator:documents-locator, accelerator:documents-analyser,
accelerator:web-search-researcher.

**Plans directory**: !`accelerator config path plans --fail-safe`

You are tasked with implementing an approved technical plan from
the configured plans directory (shown above). These plans contain phases with
specific changes and success criteria.

## Getting Started

When given a plan path:

- Read the plan completely and check for any existing checkmarks (- [x])
- Read the original work item and all files mentioned in the plan
- **Read files fully** - never use limit/offset parameters, you need complete
  context
- Think deeply about how the pieces fit together
- Create a todo list to track your progress
- Start implementing if you understand what needs to be done

If no plan path provided, ask for one.

## Implementation Philosophy

Plans are carefully designed, but reality can be messy. Your job is to:

- Follow the plan's intent while adapting to what you find
- Implement each phase fully before moving to the next
- Verify your work makes sense in the broader codebase context
- Update checkboxes in the plan as you complete sections

When things don't match the plan exactly, think about why and communicate
clearly. The plan is your guide, but your judgment matters too.

If you encounter a mismatch:

- STOP and think deeply about why the plan can't be followed
- Present the issue clearly:
  ```
  Issue in Phase [N]:
  Expected: [what the plan says]
  Found: [actual situation]
  Why this matters: [explanation]

  How should I proceed?
  ```

## Verification Approach

After implementing a phase:

- Pause and let me review all the changes you have made
- Run the success criteria checks (usually `./go` covers everything)
- Fix any issues before proceeding
- Update your progress in both the plan and your todos
- Check off completed items in the plan file itself using Edit

Don't let verification interrupt your flow - batch it at natural stopping
points.

**Validate the frontmatter**: after writing, run `corpus frontmatter
validate` over the plan file whose checkboxes you just updated:

```bash
accelerator corpus frontmatter validate --file <path>
```

If it exits non-zero, the plan violates the canonical frontmatter
standard; report the emitted violation and fix the frontmatter before
completing.

## If You Get Stuck

When something isn't working as expected:

- First, make sure you've read and understood all the relevant code
- Consider if the codebase has evolved since the plan was written
- Present the mismatch clearly and ask for guidance

Use sub-tasks sparingly - mainly for targeted debugging or exploring unfamiliar
territory.

## Resuming Work

If the plan has existing checkmarks:

- Trust that completed work is done
- Pick up from the first unchecked item
- Verify previous work only if something seems off

Remember: You're implementing a solution, not just checking boxes. Keep the end
goal in mind and maintain forward momentum.

!`accelerator config instructions implement-plan --fail-safe`