/speckit.implement Command

Relevant source files

• README.md

Purpose and Scope

The /speckit.implement command is the final execution phase of the Spec-Driven Development workflow. It transforms a validated implementation plan and task breakdown into working code by systematically executing tasks in dependency order, following test-driven development principles, and invoking local CLI commands as needed.

This command operates after the planning and task generation phases. For task generation, see /speckit.tasks Command. For quality validation during implementation, see /speckit.checklist Command.

Sources: README.md129-133 README.md259 README.md597-615

---

Prerequisites and Validation

Before execution begins, /speckit.implement validates that all required artifacts are in place:

Artifact	Location	Purpose
constitution.md	.specify/memory/	Architectural principles and constraints
spec.md	.specify/specs/NNN-feature-name/	Feature specification
plan.md	.specify/specs/NNN-feature-name/	Technical implementation plan
tasks.md	.specify/specs/NNN-feature-name/	Ordered task breakdown

The command halts if any prerequisite is missing, preventing incomplete or inconsistent implementations.

Sources: README.md603-606

---

Task Execution Model

Execution Principles:

1. Dependency Ordering: Tasks execute in the sequence defined in tasks.md, respecting inter-task dependencies (e.g., data models before services)
2. Parallel Execution: Tasks marked with [P] can execute concurrently if the AI agent supports parallelization
3. Test-First Development: When tests are requested, test tasks execute before implementation tasks for the same component
4. Checkpoint Validation: After each user story phase completes, the implementation is validated before proceeding

Sources: README.md584-594 README.md603-610

---

Input File Structure

tasks.md Format

The tasks.md file generated by /speckit.tasks provides the execution blueprint:

Key Elements:

• Phase Organization: Tasks grouped by user story for incremental delivery
• Parallel Markers: [P] suffix indicates safe parallel execution
• File Specifications: Exact paths where code should be written
• Dependency Chains: Explicit or implicit ordering requirements
• Checkpoints: Validation gates between user stories

Sources: README.md584-594

---

Execution Workflow Phases

Sources: README.md599-615

---

Task Processing Rules

Dependency Resolution

Tasks execute in the order specified in tasks.md, which already accounts for dependencies. The agent must:

1. Respect Sequential Tasks: Execute non-[P] tasks one at a time
2. Batch Parallel Tasks: Group consecutive [P] tasks for concurrent execution
3. Wait for Dependencies: Never start a task until its dependencies complete
4. Fail Fast: Halt execution if a blocking task fails

Test-Driven Development Flow

When tests are included in the task breakdown:

Sources: README.md584-594 README.md608

---

CLI Command Integration

The /speckit.implement command executes local CLI tools directly, not through remote APIs. This enables:

Supported Command Categories

Category	Example Commands	Purpose
Project Initialization	dotnet new, npm init, cargo new	Bootstrap project structure
Dependency Management	npm install, pip install, dotnet add package	Install libraries
Build & Compilation	dotnet build, npm run build, cargo build	Compile source code
Test Execution	dotnet test, npm test, pytest	Run test suites
Database Operations	dotnet ef migrations add, npm run migrate	Schema management
Development Servers	npm run dev, dotnet run, python manage.py runserver	Local testing

Command Execution Pattern

Critical Requirements:

• Local Execution: All commands run on the developer's machine, not in cloud environments
• Tool Availability: The AI agent checks for required tools before execution (see check-prerequisites.sh)
• Environment Variables: Commands respect environment variables from plan.md (e.g., NODE_ENV, ASPNETCORE_ENVIRONMENT)
• Working Directory: Commands execute in the correct project subdirectory

Sources: README.md610-613 README.md175

---

Code Generation Process

File Creation Sequence

When a task specifies a file to create/modify:

Constitutional Enforcement During Implementation

The implementation must adhere to the constitutional principles established in .specify/memory/constitution.md:

Constitutional Check	Implementation Impact
Library-First Principle	Prefer standard library features over custom abstractions
CLI Interface Mandate	Generate CLI entry points for executable functionality
Test-First Imperative	Write tests before implementation code
Simplicity Gate	Use ≤3 projects/modules unless complexity is justified
Anti-Abstraction Gate	Use framework features directly without extra layers
Integration-First Testing	Write integration tests with real dependencies

Sources: README.md404-405 README.md574

---

Error Handling and Recovery

Error Categories

Recovery Strategies

1. Automatic Fixes: Syntax errors, import statements, minor formatting issues
2. User Interaction: Missing tools, environment setup, configuration choices
3. Graceful Degradation: Skip non-critical tasks with warnings
4. Manual Intervention: Report complex errors with context for developer resolution

Sources: README.md609-610 README.md614-615

---

Output and Deliverables

Generated Artifacts

After successful execution, the following artifacts exist:

project-root/
├── src/                        # Source code
│   ├── models/                 # Data models
│   ├── services/               # Business logic
│   ├── api/                    # API endpoints
│   └── cli/                    # CLI entry points
├── tests/                      # Test suites
│   ├── unit/                   # Unit tests
│   └── integration/            # Integration tests
├── docs/                       # Generated documentation
└── .specify/
    └── specs/NNN-feature/
        ├── spec.md             # Unchanged
        ├── plan.md             # Unchanged
        └── tasks.md            # Checkboxes marked complete

Task Completion Tracking

As tasks complete, the agent marks checkboxes in tasks.md:

Sources: README.md438-459 README.md500-528

---

Integration with Other Commands

Command Sequence

Data Flow

Command	Output	Used By /speckit.implement
/speckit.constitution	constitution.md	Validates architectural compliance
/speckit.specify	spec.md	Provides feature requirements
/speckit.plan	plan.md, data-model.md, contracts/	Guides technical decisions
/speckit.tasks	tasks.md	Defines execution sequence

Sources: README.md249-270

---

Example Execution Trace

Sample tasks.md Input

Agent Execution Flow

1. Read Prerequisites: constitution.md, spec.md, plan.md, tasks.md
2. Parse Task 1 & 2: Both marked [P], execute in parallel
3. Generate Code: Create task.cs and user.cs following data-model.md
4. Parse Task 3: Depends on Task 1 completion
5. Generate Tests: Write test cases in task_tests.cs
6. Run Tests: dotnet test tests/unit/task_tests.cs (expected to fail)
7. Parse Task 4: Depends on Task 3
8. Generate Service: Write task_service.cs to pass tests
9. Run Tests: dotnet test tests/unit/task_tests.cs (expected to pass)
10. Checkpoint: Validate TaskService functionality
11. Mark Complete: Update tasks.md checkboxes

Sources: README.md584-594 README.md603-610

---

Best Practices

Before Running /speckit.implement

1. Validate Prerequisites: Ensure constitution, spec, plan, and tasks are complete
2. Install Tools: Run specify check to verify all required CLI tools are available
3. Review Tasks: Manually inspect tasks.md for completeness and ordering
4. Check Constitutional Compliance: Verify plan adheres to architectural principles

During Execution

1. Monitor Progress: Watch for task completion messages and checkpoint validations
2. Review Generated Code: Spot-check critical files as they're created
3. Test Incrementally: Run tests after each user story phase
4. Handle Errors Promptly: Address errors when they occur rather than accumulating technical debt

After Execution

1. Run Full Test Suite: Execute all tests to ensure nothing broke
2. Test Runtime Behavior: Run the application and test in browser/CLI
3. Review Checkpoints: Verify all user story checkpoints passed
4. Update Documentation: Ensure generated docs match implementation

Sources: README.md610-615

---

Relationship to Feature Branches

The /speckit.implement command operates within the feature branch context established by /speckit.specify. The branch structure follows:

main
└── 001-feature-name  (created by /speckit.specify)
    └── .specify/specs/001-feature-name/
        ├── spec.md
        ├── plan.md
        └── tasks.md  (read by /speckit.implement)

For details on branch creation and management, see Feature Creation and Branch Management.

Sources: README.md434-436 README.md441-459