mhylle/claude-skills-collection/implement-plan

Name: implement-plan
Author: mhylle

Trust tier 3

community

Source check pending

Checking that the SKILL.md file is still in the repository.

Orchestrate the execution of complete implementation plans, delegating each phase to implement-phase skill. This skill manages the full plan lifecycle including phase sequencing, user confirmation between phases, and overall progress tracking. Triggers on "implement the plan", "execute the implementation plan", or when given a path to a plan file.

Install

npx vskill@latest install mhylle/claude-skills-collection/implement-plan

SKILL.md

Implement Plan

CRITICAL: Orchestrator Pattern (MANDATORY)
Architecture
Responsibilities
When to Use
Execution Modes
Getting Started
Phase Execution Protocol
Handling Blockers
Resuming Interrupted Work
Final Completion
Progress Tracking
Reference Materials
Key Principles
Skill Dependencies

Reference files (open one when a step points to it):

references/plan-format.md: Implementation Plan Format Reference

Orchestrate the execution of complete implementation plans by delegating each phase to the implement-phase skill. This skill manages the full plan lifecycle.

CRITICAL: Orchestrator Pattern (MANDATORY)

THIS SESSION IS AN ORCHESTRATOR. YOU MUST NEVER IMPLEMENT CODE DIRECTLY.

The Orchestration Hierarchy

implement-plan (this session - ORCHESTRATOR)
    │
    │   ⛔ NEVER writes code
    │   ⛔ NEVER uses Write/Edit tools
    │   ⛔ NEVER creates files
    │
    └── implement-phase (ORCHESTRATOR for phase, run in this same session)
            │
            │   ⛔ NEVER writes code
            │   ⛔ NEVER uses Write/Edit tools
            │   ⛔ NEVER creates files
            │
            └── Subagents (DO the actual work)
                    │
                    ✅ Write code
                    ✅ Create files
                    ✅ Run tests
                    ✅ Fix issues

This holds whenever the Agent tool is available. A user's "foreground", "no background agents" or "don't poll" is about how this session waits for agents, not about who writes the code; only an explicit "write the code yourself in this session" overrides the rule, so ask when unsure.

What This Session Does

DO	DO NOT
Read plan and prompts	Write code
Discover phase prompts	Create files
Invoke implement-phase skill	Use Write/Edit tools
Track plan-level progress	Implement directly
Present results to user	Fix issues directly
Handle user confirmation	Run implementation commands

Enforcement

If you find yourself about to use Write, Edit, or NotebookEdit tools in this session:

⛔ STOP - You are violating the orchestrator pattern
✅ INSTEAD - Run implement-phase's procedure, which spawns subagents

Architecture

implement-plan (this skill - plan orchestrator)
    │
    ├── Phase 1 → implement-phase → [implementation, verification, review, ADR, sync]
    │                    ↓
    │              [user confirmation]
    │                    ↓
    ├── Phase 2 → implement-phase → [implementation, verification, review, ADR, sync]
    │                    ↓
    │              [user confirmation]
    │                    ↓
    ├── Phase N → implement-phase → [...]
    │                    ↓
    └── Final Verification & Summary

Responsibilities

This Skill (implement-plan)

Read and understand the full plan
Sequence phases correctly
Run each phase through implement-phase, in this session
Handle user confirmation between phases
Track overall plan progress
Generate final completion report

Delegated to implement-phase

All implementation work
Exit condition verification
Code review
ADR compliance
Plan file synchronization

When to Use

Implementing pre-approved technical plans or specifications
Executing phased development work with defined success criteria
Following structured implementation guides with verification steps
Resuming partially-completed implementation work

Execution Modes

Current Mode: Guided Execution

Each phase requires user confirmation before proceeding to the next. This is the default, safe mode.

Phase 1 → implement-phase → ✅ Complete → [USER CONFIRMS] → Phase 2 → ...

Future Mode: Autonomous Execution

Note: This mode is planned but not yet implemented. When enabled, the entire plan will execute without pauses between phases.

Phase 1 → Phase 2 → Phase 3 → ... → Final Report

Autonomous mode will require:

Explicit user opt-in: "implement the entire plan autonomously"
Stricter quality gates
Comprehensive rollback capability
Detailed execution log

Getting Started

When given a plan path or asked to implement a plan:

1. Locate and Read Plan

1. Find the plan file (docs/plans/, thoughts/plans/, or specified path)
2. Read the ENTIRE plan - full context is essential
3. Identify total number of phases
4. Extract task_list_id from plan metadata (for multi-session support)
5. Check for existing Tasks (TaskList shows progress from previous sessions)

Multi-Session Support: If the plan has a task_list_id in its metadata, ensure you're using the same task list:

bash

CLAUDE_CODE_TASK_LIST_ID=plan-2026-01-24-feature-name claude

This enables multiple sessions to share progress on the same plan.

2. Discover Phase Prompts

Check for pre-generated prompts from the prompt-generator skill:

# Check common prompt locations
1. Glob("docs/prompts/phase-*.md")           # Standard location
2. Glob("prompts/phase-*.md")                # Alternative location
 
# Match prompts to phases by number
phase-1-*.md  →  Phase 1
phase-2-*.md  →  Phase 2
...

Prompt Discovery Output:

● Prompt Discovery:
  Found: docs/prompts/phase-1-foundation.md      → Phase 1
  Found: docs/prompts/phase-2-data-pipeline.md   → Phase 2
  Found: docs/prompts/phase-3-agent-system.md    → Phase 3
  Missing: Phase 4 (no prompt found)
 
  Note: Phases with prompts will use pre-generated instructions.
        Phases without prompts will use plan file directly.

3. Read Related Context

# Tiered ADR reading (context conservation)
1. Read("docs/decisions/INDEX.md")              # Scan all ADRs first
2. Read("docs/decisions/ADR-NNNN.md", limit=10) # Quick Reference of relevant ones
3. Read full ADR only if needed for implementation details
 
# Read files referenced in plan
4. Load all files mentioned in the plan

4. Check Progress via Tasks

# Check for existing tasks for this plan
TaskList: Check for tasks matching "Phase N:" pattern
 
If tasks exist:
  - Resume from first non-completed task
  - Skip already-completed phases
  - Display current progress
 
If no tasks exist:
  - Tasks should have been created by create-plan
  - If missing, create them now (see create-plan Phase 7)

Task Status Display:

Tasks (2 done, 3 open):
  ✓ #1 Phase 1: Setup
  ✓ #2 Phase 2: Core Logic
  ◻ #3 Phase 3: Integration › blocked by #2
  ◻ #4 Phase 4: Testing › blocked by #3
  ◻ #5 Phase 5: Documentation › blocked by #4

5. Begin Phase Execution

For each phase:

Mark task as in_progress: TaskUpdate(task_id, status: "in_progress")
Invoke implement-phase. Its procedure loads into this session, which then acts as the phase lead through Steps 1–8; nothing comes back from elsewhere, so continue from the PHASE_RESULT block that ends Step 8.
On completion: TaskUpdate(task_id, status: "completed")

Skill(skill="implement-phase"): Execute Phase [N] of the implementation plan.
 
Context:
- Plan: [plan file path]
- Phase: [N] ([Phase Name])
- Task ID: [task_id from TaskList]
- Prompt: [prompt file path, if discovered]
- Previous Phase Status: [Complete/N/A]
 
Execute all quality gates and end with the PHASE_RESULT block.

With Prompt (preferred):

Skill(skill="implement-phase"): Execute Phase 2.
 
Context:
- Plan: docs/plans/trading-platform.md
- Phase: 2 (Data Pipeline)
- Task ID: 2
- Prompt: docs/prompts/phase-2-data-pipeline.md
- Previous Phase Status: Complete
 
The prompt contains detailed orchestration instructions.
Execute all quality gates and archive prompt on completion.

Without Prompt (fallback):

Skill(skill="implement-phase"): Execute Phase 4.
 
Context:
- Plan: docs/plans/trading-platform.md
- Phase: 4 (Integration)
- Task ID: 4
- Prompt: None (use plan directly)
- Previous Phase Status: Complete
 
No pre-generated prompt. Use plan file for phase details.

Phase Execution Protocol

Before Each Phase

Announce the phase about to start
Summarize what will be implemented
Note any dependencies on previous phases

═══════════════════════════════════════════════════════════════
● STARTING PHASE 2: Authentication Service
═══════════════════════════════════════════════════════════════
 
Objectives:
- Implement login/logout logic
- JWT token generation and validation
 
Dependencies:
- Phase 1 (Database Schema) must be complete ✅
 
Running implement-phase...

During Phase Execution

The implement-phase procedure, running in this session, handles all details:

Subagent delegation for implementation
Exit condition verification
Code review via devflow:code-review
ADR compliance checking
Plan file synchronization

Its agents report asynchronously, so this session ends turns while it waits for them. That is the phase still in progress, not the phase ending: each report resumes the phase, which runs on until Step 8.

After Each Phase

Continue from the structured result that ends implement-phase's Step 8:

yaml

PHASE_RESULT:
  status: COMPLETE | FAILED | BLOCKED
  steps:
    implementation: PASS
    exit_conditions: PASS
    code_review: PASS
    adr_compliance: PASS
    plan_sync: PASS
  manual_verification:
    - "Check login flow in browser"
  ready_for_next: true

User Confirmation Point

After each phase completes, pause for user confirmation:

═══════════════════════════════════════════════════════════════
● PHASE 2 COMPLETE: Authentication Service
═══════════════════════════════════════════════════════════════
 
Results:
  ✅ Implementation: 3 files created, 2 modified
  ✅ Exit Conditions: All passed
  ✅ Code Review: Passed with 2 recommendations
  ✅ ADR Compliance: Passed
  ✅ Plan Updated: 8 tasks marked complete
 
Manual Verification Required:
  - [ ] POST /auth/login returns token with expected claims
  - [ ] POST /auth/logout invalidates session
 
Recommendations (non-blocking):
  1. Consider using project's CustomLogger
  2. Add ADR-0012 reference to plan
 
───────────────────────────────────────────────────────────────
Please confirm manual verification steps, then respond to
proceed to Phase 3: API Endpoints
═══════════════════════════════════════════════════════════════

Handling Blockers

During a phase, implement-phase asks the user about a blocker itself, since it runs in this session, and resumes the blocked step after the answer. A PHASE_RESULT with status: BLOCKED only ends a phase when no one could be asked (an unattended run):

From implement-phase

yaml

PHASE_RESULT:
  status: BLOCKED
  blocker: "Existing JWT implementation found in src/legacy/auth.js"
  options:
    - "Proceed with new implementation"
    - "Refactor legacy code"
    - "Abort and revise plan"

Orchestrator Response

STOP further phase execution
PRESENT the blocker to user with options
AWAIT user decision
RESUME or ABORT based on decision

⛔ PHASE 2 BLOCKED
 
Issue: Existing JWT implementation found in src/legacy/auth.js.
The plan specifies creating new jwt.strategy.ts but doesn't
mention legacy code.
 
Options:
A) Proceed with new implementation, mark legacy for removal
B) Refactor legacy code instead of creating new file
C) Abort and revise the plan
 
Recommendation: Option A - cleaner separation
 
How should I proceed?

Resuming Interrupted Work

Tasks persist across sessions, enabling seamless resume:

This is the start of the file. Read the full SKILL.md on GitHub.

Security

Security scanPassed, 100 of 100Pattern checks on the skill's files.
Model reviewPassed

See the full security report

Quality evaluation

Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

SKILL.md in the repositoryCheckingskills/implement-plan/SKILL.md

Popularity

Repository stars: 13
7-day trend score: 13

Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 30 Mar 2026, 6 months ago.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

Claude Code
Cursor
GitHub Copilot
Windsurf
Codex
Gemini CLI
Cline
Amp
Roo Code
Goose
Continue
Kilo Code
Junie
Trae
OpenHands
Qwen Code
AI Agent
Tabnine Chat
Sourcegraph Cody
Amazon Q
Firebase Genkit
Sweep
Devin
Phind
Mentat
Claude Desktop
Aider
GPT Pilot
Plandex
bolt.new
v0
Replit Agent
Anse
TypingMind
BetterChatGPT
LibreChat
Warp AI
Pieces
Fig AI

Embed badge

[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/mhylle/claude-skills-collection/implement-plan/badge)](https://verified-skill.com/skills/mhylle/claude-skills-collection/implement-plan)

Something wrong with this skill or its page? Tell us.