feature-implementation

Execute multi-phase feature plans with state tracking via implementation_state.md.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/ctdio/dotfiles --skill feature-implementation-ctdio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-implementation
Source: https://github.com/ctdio/dotfiles/tree/main/claude/skills/feature-implementation
Command: npx skills add https://github.com/ctdio/dotfiles --skill feature-implementation-ctdio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams execute feature plans from ~/.ai/plans with a disciplined, phased approach. It maintains a persistent implementation_state.md to track progress, uses a Plan agent to explore both plan details and codebases, and implements features phase by phase with progressive disclosure to avoid context overload.

Core Features & Use Cases

  • Phase-driven execution: Guides work through clearly defined phases and milestones.
  • State tracking: Maintains implementation_state.md to resume work after interruptions.
  • Plan-driven exploration: Uses a Plan agent to understand the plan and the codebase before proposing steps.
  • Controlled execution: Proposes concrete steps per phase and validates against existing patterns.
  • Use Case: You have a feature plan for a new user onboarding flow; this Skill will implement it phase by phase, preserving a trace of decisions and progress.

Quick Start

Activate the feature-implementation skill for the desired feature plan path, e.g., ~/.ai/plans/<feature-name>/, then let it read the plan, initialize or update implementation_state.md, and begin phased execution with continuous progress updates.

Frequently Asked Questions about feature-implementation

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

FAQPage Schema
How do I execute a feature plan with phased delivery and progress tracking?

Feature-implementation executes multi-phase feature plans from ~/.ai/plans by maintaining persistent state tracking through implementation_state.md, using a Plan agent to explore the codebase and plan details, then implementing each phase progressively with validated outcomes. This disciplined approach prevents context overload and lets you resume work after interruptions.

What does phased feature implementation mean and when should I use it?

Phased feature implementation breaks a feature plan into clearly defined phases and milestones, executing each stage with explicit dependencies and codebase exploration before moving forward. Use this approach when you have complex features requiring multiple steps, team coordination, or need to maintain a decision trace across development sessions.

How do I track implementation progress across feature phases?

Implementation_state.md records phase completion, decisions made, and current progress status throughout execution. This persistent state file lets you resume from where you left off, avoids repeating work, and provides a trace of what was explored and why each phase decision was made.

Can I use phased feature implementation with existing codebase patterns?

Yes. The Skill uses a Plan agent to assess existing codebase state and patterns before proposing implementation steps, ensuring new phases validate against established conventions and dependencies already in place, maintaining consistency across your feature and existing code.

What prerequisites do I need before starting phased feature execution?

You need a feature plan file in ~/.ai/plans/<feature-name>/ that defines phases, dependencies, and codebase areas to explore. The Skill reads this plan, initializes implementation_state.md if needed, and begins phase-by-phase execution with continuous progress updates.

How does the Plan agent help with feature implementation?

The Plan agent explores both the plan details and your codebase to understand requirements and existing state before implementation begins, reducing guesswork and ensuring proposed steps fit your actual architecture and dependencies.