create-implementation

Create Implementation

Implements a feature or task following its specification, plan, and task decomposition. Produces working code that passes tests and meets all acceptance criteria.

Prerequisites

• Apply the shared SDLC conventions in skills/sdlc/references/shared.md.
• If no argument is provided, locate the feature directory under .sdlc/features/ whose frontmatter issue field references $ISSUE_NUMBER.
• A task description, specification, or plan provided in context or as $1
• .sdlc/features/N-<slug>/lifecycle.md (optional, if a lifecycle document was produced): implement state machines, transition guards, invariants, and retention policies alongside feature code
• .sdlc/features/N-<slug>/telemetry.md (optional, if a telemetry plan was produced): implement analytics events and telemetry alongside feature code
• .sdlc/features/N-<slug>/observability.md (optional, if an observability plan was produced): implement logging, metrics, tracing, and health checks alongside feature code
• Access to the codebase for reading and editing
• Test suite available (or created alongside the implementation)

Workflow

Read spec / task
        |
        v
Create or reuse feature branch
        |
        v
Understand codebase context
(patterns, conventions, architecture)
        |
        v
Verify test coverage of code to modify
(add characterization tests if under-tested,
 commit them separately)
        |
        v
Implement in small, verifiable steps
        |
        v
Run tests after each step
        |
        v
All acceptance criteria met?
     /         \
   Yes           No
    |             |
    v             v
  Done          Fix gaps

Steps

1. Read the task, specification, acceptance criteria, lifecycle document, telemetry plan, and observability plan (if present).
2. Set the task frontmatter status: in-progress in the corresponding .sdlc/features/N-<slug>/tasks/N-<slug>.md file.
3. Update the Task Progress table in progress.md to reflect the in-progress status.
4. Set up a feature branch (see Branching Strategy below).
5. Explore the codebase to understand existing patterns, naming conventions, and architecture.
6. Identify which files need to be created or modified.
7. For every existing part of the code you are about to modify, check its current test coverage. If it is not well covered, first write characterization tests that pin down the existing behavior. This keeps you from unintentionally changing behavior with your modifications.
8. Commit the characterization tests separately from the implementation changes, so there is a before/after trace of how the tests evolved.
9. Implement the changes in small increments, verifying each step with tests. Update the characterization tests as the behavior intentionally changes.
10. If a lifecycle document exists, implement state machines, transition guards, invariants, and retention policies as part of each relevant code change.
11. If a telemetry plan exists, implement analytics events and telemetry as part of each relevant code change.
12. If an observability plan exists, implement logging, metrics, tracing, and health checks as part of each relevant code change.
13. Ensure all acceptance criteria are met.
14. Check for code quality issues (naming, duplication, dead code).
15. Review the full diff and confirm the important parts of the changed code are covered by tests (see Test Coverage of Changes below).
16. Run the full test suite and confirm it passes.