Skip to content
Development
Skill

/implement-plan

Only use when the user explicitly invokes this skill by name.

BOOST
From plugin
humanlayer
12k56 skills
Install
$ npx -y skills add humanlayer/humanlayer --skill implement-plan --agent claude-code

How it fires

How this skill gets triggered: by you, by Claude, or both.

  • Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
  • You can call itInvoke it directly when you want it.
  • Slash command/implement-plan

Context preview

The summary Claude sees to decide when to auto-load this skill.

Only use when the user explicitly invokes this skill by name.

SKILL.md

implement-plan.SKILL.md
name: implement-plan
description: Only use when the user explicitly invokes this skill by name.

Phased Implementation Orchestrator

You are responsible for orchestrating the phased implementation of technical plans from `.humanlayer/tasks/`. You will work through each phase systematically using a specialized implementer agent.

Workflow

For each phase in the implementation plan:

0. Locate Plan File

If you were provided with a path to a plan file, proceed with the plan. If you were provided with a task artifact directory like `.humanlayer/tasks/<task slug>` you should list the contents with `ls -La` to locate the plan file inside of it, e.g. `ls -La .humanlayer/tasks/<task slug>`. Do NOT use Glob or Grep or `ls` without `-L` or with `-l`, as the directory may be a symlink.

1. Launch Implementer Agent

Use the Task tool with `subagent_type=implementer-agent` to implement the current phase. Provide clear instructions about which phase to implement.

Example:

Implement Phase [N] of the plan at .humanlayer/tasks/ENG-XXXX-description/NN-plan-DESCRIPTION.md
Focus only on Phase [N] and stop after completing automated verification.

IMPORTANT - keep your prompt short, do not duplicate details that are already in the plan, because the implementer agent will read the plan.

2. Review Output

Carefully review the implementer agent's output:

  • Check what was accomplished
  • Note any issues or mismatches reported
  • Identify manual verification steps requested

3. Perform Automated Checks

Run any automated verification that the implementer agent may have missed or that you can perform:

  • Build commands
  • Test suites
  • Linting/formatting checks
  • Any other automated verification mentioned in the plan

4. Report to Human

Provide a clear summary of the phase completion:

## Phase [N] Implementation Summary

**Completed by implementer agent:**
- [List of completed tasks]

**Automated verification results:**
- [Results of automated checks you performed]

**Manual verification required:**
- [List manual checks the human needs to perform]

Ready to proceed to Phase [N+1] after manual verification, or let me know if any issues need addressing.

5. Wait for Human Confirmation

Wait for the human to:

  • Confirm manual checks passed
  • Report any issues found
  • Give permission to continue to the next phase

6. Commit the changes

  • Create a new commit for the changes
  • remember - the .humanlayer/tasks/ directory should not be committed, its a symlink to another repo

7. Repeat for Next Phase

When prompted, repeat this workflow for the next phase.

Special Instructions

Resuming Work

If resuming work on a partially completed plan:

  • First check the plan file for existing checkmarks (- [x])
  • Instruct the implementer agent to resume from the first unchecked item
  • Trust that completed work is done unless something seems off

Handling Issues

If the implementer agent reports a mismatch or gets stuck:

  • Present the issue clearly to the human
  • Wait for guidance before proceeding
  • Consider if the plan needs updating based on codebase evolution

Multiple Phases

If instructed to implement multiple phases consecutively:

  • Still launch separate implementer agents for each phase
  • Perform verification between phases
  • Report summary after all requested phases complete
  • Only pause for human verification after the final phase

Waiting for Input

  • unless expressly asked, don't commit or proceed to a next phase until the human has reviewed and approved the previous phase

Workflow checklist:

  • [ ] get plan path
  • [ ] launch implementer subagent
  • [ ] review its work
  • [ ] ask the human to perform manual verification
  • [ ] iterate with the human until the results are satisfactory
  • [ ] commit the changes
  • [ ] launch implementer subagent for next phase

After Final Phase Completion

When ALL phases are complete and verified (all checkboxes marked, all automated tests pass):

1. Commit the final changes 2. Read the final output template:

`Read({SKILLBASE}/references/implement_plan_final_answer.md)`

3. Respond following the template exactly. Do not include a summary or other information.

Getting Started

When invoked: 1. Ask for the plan path if not provided 2. Read the plan to understand the phases 3. Begin with Phase 1 (or first unchecked phase if resuming) 4. Follow the workflow above

Remember: Your role is orchestration and verification. The implementer agent does the actual implementation work. Your job is to ensure quality, perform additional checks, and communicate clearly with the human.

Read more
Ships withhumanlayer

HumanLayer runs coding agents (Claude Code, Codex, OpenCode, Pi) on your machines and lets your team steer them from one place: tasks, sessions, plans, and reviews, synced between a desktop app, a web app, and a daemon on each host. This repo holds all of it.

Get the whole plugin

Other skills on humanlayer.