implement

Execute development plan steps and record implementation notes in .thoughts directories.

1|Updated Jan 24, 2023
One-click install
npx skills add https://github.com/KaiNakamura/dotfiles --skill implement-kainakamura
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implement
Source: https://github.com/KaiNakamura/dotfiles/tree/main/claude/skills/implement
Command: npx skills add https://github.com/KaiNakamura/dotfiles --skill implement-kainakamura

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns written development plans into concrete codebase actions and records the results, removing ambiguity and ensuring each planned step is executed and documented.

Core Features & Use Cases

  • Plan-driven implementation: Reads the most recent plan from .thoughts/iteration-NN/plan and executes changes step-by-step as directed.
  • Strict safety checks: Stops and requests user guidance whenever a key decision is missing, a plan is ambiguous, or a plan step appears incorrect.
  • Traceable outputs: Creates a new implementation note under .thoughts/iteration-NN/implementation/ with the next version number to preserve history and auditability.
  • Use Case: An agentic workflow where a developer writes a multi-step refactor plan and asks the Skill to apply each step and record the implementation details.

Quick Start

Implement the next step from the current plan in .thoughts by following the plan exactly and create the corresponding implementation note in the next implementation-NN.md file.

Frequently Asked Questions about implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute a development plan step-by-step and record the implementation?

To execute a development plan, the Skill reads the most recent plan from your .thoughts/iteration-NN directory, applies code changes exactly as directed, and writes a new implementation-NN.md note to preserve history.

What is plan-driven implementation in a repository workflow?

Plan-driven implementation is the process of reading a written development plan and turning it into concrete codebase actions, removing ambiguity by executing each step exactly as directed and stopping for missing decisions.

How do I track implementation history across multiple iterations?

You track implementation history by writing traceable output notes to .thoughts/iteration-NN/implementation/ directories, where each execution creates a new implementation-NN.md file with the next version number for auditability.

Does the implementation Skill stop when a plan step is ambiguous?

Yes, the implementation Skill enforces strict safety checks and halts execution to request user guidance whenever a key decision is missing, a plan is ambiguous, or a plan step appears incorrect.

What do I need to set up before running plan execution in .thoughts directories?

Before running plan execution, you need a development plan stored in a .thoughts/iteration-NN/plan directory and any user-supplied thought files, so the Skill can read the specified plan and detect the current iteration.