sdd-implementation

Execute planned implementation tasks in dependency order from spec files.

192|21|Updated Sep 19, 2025
One-click install
npx skills add https://github.com/madebyaris/spec-kit-command-cursor --skill sdd-implementation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sdd-implementation
Source: https://github.com/madebyaris/spec-kit-command-cursor/tree/main/.cursor/skills/sdd-implementation
Command: npx skills add https://github.com/madebyaris/spec-kit-command-cursor --skill sdd-implementation

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill orchestrates the execution of planned implementations by translating specs and todo-lists into actionable steps that align development work with defined plans, reducing drift between planning and delivery.

Core Features & Use Cases

  • Execute implementations directly from formal specs: load plan.md, spec.md, tasks.md, and todo-list.md and process tasks in dependency order.
  • Generate code and build features according to the plan while maintaining traceability with completion markers.
  • Use in real projects to drive roadmap execution, validation, and ongoing evolution through discoveries and blockers.

Quick Start

Start by loading the active specs and running the plan, then execute tasks in order:

  • /sdd-full-plan blog-platform to generate a complete roadmap
  • /implement to begin execution and update the todo-list as work progresses
  • Monitor progress with the progress.sh script and verify results with sdd-verifier after completion

Frequently Asked Questions about sdd-implementation

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

FAQPage Schema
How do I execute a planned implementation from spec files in a software project?

Spec-driven development executes planned implementations by loading plan.md, spec.md, tasks.md, and todo-list.md from the active specs directory. It translates these formal specs into actionable steps, processes tasks in dependency order, and maintains traceability with completion markers to reduce drift between planning and delivery.

What is spec-driven development and how does it manage code generation tasks?

Spec-driven development orchestrates code generation by translating formal specs into actionable todo-lists and executing tasks sequentially. It enforces sequential execution, marks completed items, records blockers, and maintains alignment between your development work and the defined plan.

Can I track implementation progress and blockers using a todo-list workflow?

Yes, this plan execution workflow updates the todo-list as work progresses, marking completed items and recording any blockers encountered. You can monitor ongoing progress using the progress.sh script and verify final results with sdd-verifier after completion.

Do I need formal spec documents before I can start feature building with this approach?

Yes, plan-driven feature building requires formal spec documents located in specs/active/[task-id]/. You must generate a complete roadmap containing plan.md, spec.md, tasks.md, and todo-list.md before beginning execution to ensure proper sequential task processing.

What's the best way to start a plan-driven implementation for a new feature?

Start by generating a complete roadmap using a full-plan command for your feature, then begin execution to process the generated tasks in dependency order. As execution proceeds, the workflow updates the todo-list, tracks progress via progress.sh, and validates results with sdd-verifier.

Why does my spec-driven implementation drift from the original plan during code generation?

Drift occurs when development work lacks strict alignment with defined plans. This skill solves drift by loading formal specs, enforcing sequential execution in dependency order, and maintaining traceability through completion markers and recorded blockers throughout the feature building process.