implementation

Implements bounded code changes test-first against observable success criteria.

4|Updated Jun 19, 2026
One-click install
npx skills add https://github.com/douglance/sdlc-plugin --skill implementation-douglance
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implementation
Source: https://github.com/douglance/sdlc-plugin/tree/main/.rulesync/skills/implementation
Command: npx skills add https://github.com/douglance/sdlc-plugin --skill implementation-douglance

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a clear requirement into working code often leads to oversized diffs, untested changes, and scope creep. This Skill enforces a disciplined test-first loop so every change is small, verified, and keeps the codebase green. ## Core Features & Use Cases - Test-First Loop: Write a failing test that captures the next behavior slice, make it pass with the simplest code, then run the verify command before moving on. - Bounded Changes: Produce the smallest diff that meets the requirement, respect the out_of_scope fence, and match surrounding code style. - Engineer Agent Delegation: Hand off independent bounded work to the engineer agent, or work locally when coordination is needed. - Use Case: Given a scoped specification for a new API endpoint, implement it slice by slice with failing tests first, keeping the test suite green at every step and reporting any material deviations. ## Quick Start Implement the approved specification test-first, delivering small verified changes one slice at a time.

Frequently Asked Questions about implementation

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

FAQPage Schema
How do I implement a feature using test-driven development?▼

Write a failing test that captures the next slice of behavior, then write the simplest code that makes it pass. Run the verify command after each slice: if green, move to the next slice; if red, fix before continuing.

How to keep code changes small during implementation?▼

Make the smallest diff that meets the requirement and touch only what the task demands. Respect the out_of_scope fence, avoid refactoring unbroken code, and match the surrounding code's style and idioms.

When should implementation work be delegated to an engineer agent?▼

Delegate to the engineer agent when a bounded implementation can proceed independently. Work locally when the change requires coordination or cannot be cleanly isolated.

Who writes tests during the implementation phase?▼

The implementer writes the code's own tests test-first as part of each slice. The tester role adds adversarial tests later in the testing phase, never as a substitute for implementation tests.

What are the limitations of test-first incremental implementation?▼

It requires clear requirements and an observable success criterion before starting. It is not suited for exploratory work where the desired behavior is still undefined; use feasibility-analysis or requirements-gathering first.