Execute Implementation

You are executing the implementation tasks defined in the task list, phase by phase, following TDD principles and respecting task dependencies.

Upstream source: github/spec-kit

Prerequisites

• A task list must exist at specs/[###-feature-name]/tasks.md
• A plan must exist at specs/[###-feature-name]/plan.md

If these don't exist, instruct the user to run /spec-kit:tasks first.

Workflow

Step 1: Identify the Feature

• If the user specifies a feature name/number, locate it in specs/
• If multiple features exist and none is specified, list available features and ask the user to choose
• If only one feature exists, use it automatically

Step 2: Check Checklists Status

If specs/[###-feature]/checklists/ directory exists:

• Scan all checklist files in the directory
• For each checklist, count total items and incomplete items (- [ ])
• Create a status table:

| Checklist            | Total | Completed | Incomplete | Status  |
|----------------------|-------|-----------|------------|---------|
| requirements.md      | 12    | 12        | 0          | ✓ PASS  |
| [other checklist]    | 8     | 5         | 3          | ✗ FAIL  |

• If any checklist is incomplete: Display the table and ask: "Some checklists are incomplete. Do you want to proceed with implementation anyway? (yes/no)"
  • If user says "no/wait/stop", halt execution
  • If user says "yes/proceed/continue", proceed to Step 3
• If all checklists are complete: Display the table and automatically proceed

Step 3: Load All Context

Read and internalize:

• specs/[###-feature]/tasks.md — the task list to execute
• specs/[###-feature]/plan.md — architectural decisions and structure
• specs/[###-feature]/spec.md — requirements and acceptance criteria
• specs/[###-feature]/data-model.md — data structures (if exists)
• specs/[###-feature]/contracts/ — interface contracts (if exists)
• specs/[###-feature]/research.md — technical decisions (if exists)
• .speckit/constitution.md — project principles

Report context loaded:

Implementation Context:
  tasks.md      — [count] tasks ([count] remaining)
  plan.md       — Loaded
  data-model.md — [Loaded / Not found]
  contracts/    — [Loaded / Not found]
  research.md   — [Loaded / Not found]

Step 4: Project Setup Verification

Based on the detected tech stack from plan.md, verify appropriate ignore files exist and contain essential patterns:

Detection logic:

• Check for git repo → verify/create .gitignore
• Check for Dockerfile → verify/create .dockerignore
• Check for package.json/.npmrc → verify/create .npmignore (if publishing)
• Check for eslint config → verify .eslintignore or config ignores

If ignore file already exists: Verify it contains essential patterns, append missing critical patterns only

Common patterns by tech stack:

• Node.js/TypeScript: node_modules/, dist/, build/, *.log, .env*
• Python: __pycache__/, *.pyc, .venv/, venv/, dist/, *.egg-info/
• Java: target/, *.class, *.jar, .gradle/, build/
• Go: *.exe, *.test, vendor/, *.out
• Rust: target/, debug/, release/
• Universal: .DS_Store, Thumbs.db, *.tmp, *.swp

Step 5: Parse Task Phases

Extract the phase structure from tasks.md:

• Identify all phases and their tasks
• Note completed tasks [x]
• Note parallelizable tasks [P]
• Determine the current execution point (first unchecked task)

Step 6: Execute Phase by Phase

Process tasks in strict phase order: Setup → Foundational → P1 Stories → P2 Stories → P3 Stories → Polish

For each phase:

1. Announce the phase: Starting Phase [N]: [Phase Name] ([count] tasks)

2. Execute each task in order:

   • For test tasks (if TDD): Write test first, verify it FAILS (red phase)
   • For implementation tasks: Write code to make tests pass (green phase)
   • For [P] parallel tasks: Execute in any order within the group
   • After completing each task: immediately mark it [x] in tasks.md

3. Execution rules:

   • Mark tasks [x] in tasks.md as they complete — don't batch updates
   • If a task fails or cannot complete, STOP and report:

     BLOCKED: Task T### — [Description]
     Reason: [What went wrong]
     Suggestion: [How to resolve]
     

   • Do NOT skip failed tasks and continue — halt the phase
   • Wait for user input before continuing after a failure

4. Phase completion checkpoint:

   Phase [N] Complete: [Phase Name]
     Completed: [count] tasks
     Total Progress: [completed]/[total] tasks ([percentage]%)
   

   For user story phases: validate the story works independently before moving to the next story

Step 7: Progress Reporting

After each task completion:

[x] T### [Description] — Done
    Progress: [completed]/[total] ([percentage]%)

Step 8: Final Validation

After all tasks are complete:

1. Requirements Coverage: Verify every FR-### from spec is addressed
2. Test Coverage: Verify tests exist for all user stories (if TDD was used)
3. Constitution Compliance: Quick check that implementation follows all principles
4. Report:

Implementation Complete: [FEATURE NAME]

  Tasks: [total] completed
  Phases: [count] phases executed

  User Story Status:
    US1 (P1): ✅ Implemented and independently testable
    US2 (P2): ✅ Implemented and independently testable
    US3 (P3): ✅ Implemented and independently testable

  Requirements Coverage:
    FR-001: Covered by T005, T006
    FR-002: Covered by T008
    ...

  Constitution Compliance: All principles satisfied

  Next steps:
    - Review the implementation
    - Run the full test suite
    - Consider running /spec-kit:analyze for cross-artifact consistency check

Important Rules

• NEVER skip a task without explicit user approval
• If TDD requested: write test → verify it fails → implement → verify it passes
• Mark tasks [x] in tasks.md IMMEDIATELY after completion
• Respect phase ordering strictly — do not start next phase until current is fully complete
• If a foundational task fails, the entire implementation is blocked
• Parallel tasks [P] can be reordered within their group but must all complete before the next non-parallel task
• Keep the user informed of progress — don't go silent during long implementations