Agent skill

Implement

by genkovich in genkovich/sdd

A skill your agent uses to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task.

MITAuto-check passedTesting & QA

Install Implement

skills CLI
$ npx skills add genkovich/sdd --skill implement -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install genkovich/sdd implement --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/implement .claude/skills/implement && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
implement
GitHub stars
171
Token cost
~2.5k tokens
SKILL.md length
1,036 words
Files
9 (incl. references)
Skills in repo
21
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task.

  • Works in 10 steps: Preconditions. Verify tasks.json exists… → Ensure the settings file (first thing,… → Detect commands. Run the stack-agnostic… → …
  • Implement a feature from its tasks.json with test-driven development — writes a failing test first
  • SKILL.md covers Owner, Inputs, Protocol and Decision tree (compact), plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Implement is an agent skill from genkovich/sdd. Use to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task. Triggers on "implement {slug}", "build {slug}", "TDD {slug}", "code up the tasks for {slug}", "/sdd:implement {slug}", "імплементуй {slug}", "реалізуй фічу {slug}", "напиши код за задачами". Reads docs/features/{slug}/tasks.json + the upstream artifacts, detects the repo's test/lint/vet commands stack-agnostically, builds a dependency DAG, and runs one…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files, including reference files (for example `references/command-detection.md`, `references/decision-tree.md` and `references/escalation.md`).

It sits in Testing & QA, covering Test-driven development and Refactoring. The repository describes itself as: Spec-Driven Development for Claude Code: 12 atomic Socratic skills + a TDD implement engine (agent-team & dynamic-workflow modes). The licence is MIT.

When your agent uses it

  • Implement a feature from its tasks.json with test-driven development — writes a failing test first
  • Commits per task
  • Implement {slug}
  • Code up the tasks for {slug}

Example prompts

  • “implement {slug}”
  • “build {slug}”
  • “TDD {slug}”
  • “/implement”

Requirements

  • Docker

Workflow steps

10 steps, taken from the first numbered list in SKILL.md.

  1. Preconditions. Verify tasks.json exists and parses; load the upstream artifacts list. Detail → ./references/inputs.md.
  2. Ensure the settings file (first thing, after this skill's own gate). If .claude/sdd.local.md is absent, create it now from the canonical…
  3. Detect commands. Run the stack-agnostic cascade (settings override → Makefile → package scripts → language manifests → Docker probe for…
  4. Build the DAG. Parse tasks.json, validate deps is acyclic, topologically sort into phases (Kahn). Compute task_count, longest_chain…
  5. Pick the mode. Run the decision tree (below; full form → ./references/decision-tree.md). Apply the guards.
  6. Generate the run-plan. Sequential → an ordered task list. Team → a shared TaskList with the full task text in each body. Workflow → a…
  7. Banner. Print the active mode and the settings that drove it: mode=<…> tdd=<…> isolation=<…> parallel= integration=<…>. The user sees…
  8. Execute in the chosen mode. Every task runs the TDD cycle → ./references/tdd-loop.md. A layer: migration task first promotes its staged…
  9. Per-task gate + commit. After GREEN+REFACTOR: unit + (integration if available) + lint + vet must be clean, then commit task-scoped with…
  10. Summary + hand off. Report covered AC, commits made (with SDD-Task trailers), any task dropped/blocked, and the per-task gate results…

What it can do on your machine

Read from SKILL.md and the folder at commit 4403913. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Implement loads about 2.5k tokens when it runs, and up to ~12k if it reads all its reference files. Until then it costs about 180 tokens; SKILL.md has 1,036 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~180
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~12k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from genkovich/sdd at commit 4403913, republished under its MIT licence (© genkovich). 1,036 words, ~2,509 tokens.

Download SKILL.mdSave it as .claude/skills/implement/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
implement
description
Use to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task. Triggers on "implement {slug}", "build {slug}", "TDD {slug}", "code up the tasks for {slug}", "/sdd:implement {slug}", "імплементуй {slug}", "реалізуй фічу {slug}", "напиши код за задачами". Reads docs/features/{slug}/tasks.json + the upstream artifacts, detects the repo's test/lint/vet commands stack-agnostically, builds a dependency DAG, and runs one of three modes — sequential single-agent TDD, an agent team (TeamCreate), or a dynamic Workflow — chosen from settings + DAG shape with graceful fallback. Hard-refuses if tasks.json is missing.
model
inherit
effort
medium
agents
test-author, implementer, reviewer

Skill: implement

The implementation engine. It turns tasks.json into committed, tested code through a strict TDD cycle per task — SELECT → RED → GREEN → REFACTOR → GATE → COMMIT — and orchestrates that cycle in one of three modes (sequential / agent-team / dynamic-workflow) picked by an unambiguous decision tree. Everything is stack-agnostic: the test, lint, and vet commands are detected, never hard-coded.

This file is the spine. Each step delegates to a file in references/.

Owner

Tech Lead drives; the engine runs the cycle. The three subagents ship with the plugin: test-author (RED), implementer (GREEN/REFACTOR/GATE), reviewer (read-only review).

Inputs

  • <slug> — feature slug.
  • Gate (hard refuse): docs/features/<slug>/tasks.json. Missing → «run tasks <slug> first».
  • Read for context (the agents read these directly, not via paraphrase): spec.md (AC), data-model.md + the staged migrations under docs/features/<slug>/migrations/ (a layer: migration task promotes these into the live migrations/ tree — see ./references/inputs.md), contracts/openapi.yaml, test-plan.md, sad.md, Accepted adr/.
  • Settings: .claude/sdd.local.md — created with documented defaults by whichever of the six creating skills runs first (normally specify at the backbone start; implement creates it too if you jump straight here) per ../_shared/settings-file.md; values are tuned only by ../config/SKILL.md. Which keys this engine reads → ./references/settings.md.

Protocol

  1. Preconditions. Verify tasks.json exists and parses; load the upstream artifacts list. Detail → ./references/inputs.md.
  2. Ensure the settings file (first thing, after this skill's own gate). If .claude/sdd.local.md is absent, create it now from the canonical template — documented defaults + the self-documenting body — and patch .gitignore; if it exists, read it and never overwrite. The one procedure lives in ../_shared/settings-file.md. Creating is unconditional; changing values is only ever offered by config. Say one line: «.claude/sdd.local.md created with documented defaults — /sdd:config to tune it». Which keys this engine then reads, and how model + effort resolve at dispatch → ./references/settings.md.
  3. Detect commands. Run the stack-agnostic cascade (settings override → Makefile → package scripts → language manifests → Docker probe for the integration tier) to resolve unit / integration / lint / vet commands. Print what was detected. → ./references/command-detection.md.
  4. Build the DAG. Parse tasks.json, validate deps is acyclic, topologically sort into phases (Kahn). Compute task_count, longest_chain, parallel_width. Mark serialization lanes (layer: migration; tasks with overlapping files_hint).
  5. Pick the mode. Run the decision tree (below; full form → ./references/decision-tree.md). Apply the guards.
  6. Generate the run-plan. Sequential → an ordered task list. Team → a shared TaskList with the full task text in each body. Workflow → a generated Workflow script (DAG → Kahn phases → fan-out pipeline). → ./references/team-exec.md / ./references/workflow-exec.md.
  7. Banner. Print the active mode and the settings that drove it: mode=<…> tdd=<…> isolation=<…> parallel=<n> integration=<…>. The user sees exactly how the engine will behave before it acts.
  8. Execute in the chosen mode. Every task runs the TDD cycle → ./references/tdd-loop.md. A layer: migration task first promotes its staged migration(s) (docs/features/<slug>/migrations/<NN>_*) into the live migrations/ tree — assigning the real sequence number / timestamp per the repo's convention, in ordinal order — then applies + reverts them; detail → ./references/inputs.md.
  9. Per-task gate + commit. After GREEN+REFACTOR: unit + (integration if available) + lint + vet must be clean, then commit task-scoped with trailers SDD-Task: <id> and SDD-AC: <id> (one per satisfied AC). Tasks in one compile-coupled lane (shared contract file in files_hint) pass one shared gate and one commit carrying every task's trailers — the sanctioned exception in ./references/tdd-loop.md §COMMIT. Update tracker.md → done.
  10. Summary + hand off. Report covered AC, commits made (with SDD-Task trailers), any task dropped/blocked, and the per-task gate results. Then emit the stage-handoff block per ../_shared/handoff.md — What I did (covered AC, commits with SDD-Task trailers, gate results) + Review (the committed diff + tasks/tracker.md) + Run next (/clear, then /sdd:review <slug> — a clean-context pass over the whole diff), then /sdd:ship <slug>. In team mode the reviewer may also run per-task, but the authoritative independent review of the whole change lives in the review skill — implement does not self-certify.
Show full SKILL.md (424 more words)Show less

Decision tree (compact)

parallel_eligible := isolation==worktree AND max_parallel>1 AND parallel_width>=2
                     AND (size in {M,L,XL} OR task_count>=4)

if team_mode AND parallel_eligible:                          → AGENT TEAM (TeamCreate) over the DAG
elif workflow_mode=="auto" AND parallel_eligible AND Workflow-available: → DYNAMIC WORKFLOW
else:                                                        → SEQUENTIAL single-agent TDD (topo order)

Guards (apply before dispatch): team_mode but not eligible → warn + downgrade to the next mode. max_parallel>1 with isolation: inplace → clamp parallel to 1 (no two agents edit one tree). workflow_mode: off → never generate a Workflow. tdd: false → skip RED (warn loudly — you lose the safety net). require_integration: always but Docker absent → BLOCK before dispatch; auto → run unit-only and mark integration NON-red; never → skip the integration tier. Full table → ./references/decision-tree.md. Graceful degrade: if Workflow/TeamCreate is unavailable at runtime, fall through to sequential.

TDD cycle (per task)

SELECT → RED → GREEN → REFACTOR → GATE → COMMIT. The RED step is load-bearing: write the test first, run it, and classify the first run — GOOD red (assertion fails / unimplemented) vs BAD red (the test itself won't compile → fix the test) vs false-pass (green immediately → the test is too weak, strengthen it) vs NON-red (skipped because Docker is absent → governed by require_integration, counts as neither red nor green). Quote the failing line before writing any production code. Escalation on persistent red → ./references/escalation.md: more-capable model → retry → split the task → if the test encodes a wrong AC, ask a human (never weaken the test) → rollback to the last green. stop_on_red decides halt vs drop-and-continue (dependents auto-block).

Definition of Done

  • Every task in tasks.json is either committed (test-first, gate-clean, SDD-Task/SDD-AC trailers) or explicitly reported as dropped/blocked with the reason.
  • Unit gate green; integration green where available (or NON-red recorded with the policy reason); lint + vet clean per the detected commands.
  • The active mode + settings were printed in the banner before execution.
  • tracker.md reflects final status; the summary reports the gate results and hands off to review (the independent review gate) — implement does not self-certify the whole change.
  • The per-task GATE (unit + integration + lint + vet) is this skill's structural self-check (../_shared/self-check.md); its results are reported in the handoff.

Anti-patterns

  • Code before the test. RED first, always (unless tdd: false, which warns).
  • Weakening a test to make it pass. If the AC is wrong, ask a human and fix the AC; never edit the test to be less strict.
  • Skipping the RED classification. A false-pass that looks green hides a useless test.
  • Parallel agents editing one working tree. Parallelism requires worktree isolation — the guard clamps it.
  • Committing with a red or skipped gate and calling it done. A NON-red integration tier must be labelled, not hidden.
  • Spawning a team for <4 tasks — coordination overhead exceeds the gain; the eligibility check forbids it.
  • Claiming integration passed when Docker was absent. Report NON-red honestly.

References & template

inputs.md · settings.md · command-detection.md · decision-tree.md · tdd-loop.md · team-exec.md · workflow-exec.md · escalation.md — all in ./references/.

© genkovich, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (references) in skills/implement of genkovich/sdd.

  • SKILL.md
  • references/command-detection.md
  • references/decision-tree.md
  • references/escalation.md
  • references/inputs.md
  • references/settings.md
  • references/tdd-loop.md
  • references/team-exec.md
  • references/workflow-exec.md

Open the folder on GitHubat commit 4403913

Compare with similar skills

Implement next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Implement compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Implement this skillgenkovich/sdd171—~2.5kAutomated safety check: PassMIT
TDD WorkflowhellangleZ/burn-in-cceverywhere-ralph11211 repos~2.4kAutomated safety check: PassNone
TDD Methodoly Expertthedaviddias/skill-check190—~2.2kAutomated safety check: PassMIT
TDDDanMcInerney/architect-loop626—~730Automated safety check: PassMIT
TDD Workflowaffaan-m/ECC274k1 repos~2.6kAutomated safety check: PassMIT
Fixjvm-skills/jvm-skills140—~695Automated safety check: PassApache-2.0

Similar skills

  • TDD Workflow

    hellangleZ/burn-in-cceverywhere-ralph

    A skill your agent uses when writing new features, fixing bugs, or refactoring code.

    112 GitHub starsUsed in 11 repos~2.4k tokens
    Testing & QAAuto-check passed
  • TDD Methodoly Expert

    thedaviddias/skill-check

    A skill your agent uses when implementing features or fixing bugs with strict Test-Driven Development (TDD).

    190 GitHub stars~2.2k tokensUpdated 4 mo ago
    Testing & QAAuto-check passed
  • TDD

    DanMcInerney/architect-loop

    Test-driven development for factory builders. An agent skill from DanMcInerney/architect-loop.

    626 GitHub stars~730 tokensUpdated 24 days ago
    Testing & QAAuto-check passed
  • TDD Workflow

    affaan-m/ECC

    Yeni özellikler yazarken, hata düzeltirken veya kod refactor ederken bu skill'i kullanın.

    274k GitHub starsUsed in 1 repo~2.6k tokens
    Testing & QAAuto-check passed
  • Fix

    jvm-skills/jvm-skills

    Fix a bug or missing feature using TDD — write failing test first, then fix, refactor, verify, beautify.

    140 GitHub stars~695 tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Test Driven Development

    dzhalaevd/Donatello

    Use as a workflow overlay when implementing any feature, bugfix, refactor, or behavior change before writing production code

    135 GitHub stars~1.1k tokensUpdated 4 days ago
    Testing & QAAuto-check passed

More from genkovich/sdd

All 21 skills in this repo
  • Fix

    genkovich/sdd

    A skill your agent uses to fix a reported bug spec-first: reproduce it, trace the symptom to the owning feature's acceptance criteria, pin it with a failing (RED) test, apply the minimal GREEN fix…

    171 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed
  • Interview

    genkovich/sdd

    Use BEFORE roadmap or specify to get the idea OUT OF YOUR HEAD and onto disk — a Socratic interview that surfaces hidden assumptions, names tradeoffs, exposes imprecisions and proposes fresh angles…

    171 GitHub stars~3.8k tokensUpdated 1 mo ago
    Auto-check passed
  • Classify Size

    genkovich/sdd

    A skill your agent uses to classify a feature into XS/S/M/L/XL and write docs/features/{slug}/.size plus the pipeline route docs/features/{slug}/.route (quick|standard|full) so later skills know how…

    171 GitHub stars~1.8k tokensUpdated 1 mo ago
    Auto-check passed
  • Decide Adr

    genkovich/sdd

    A skill your agent uses to record a post-hoc or asynchronous architecture decision as a MADR ADR when it was NOT captured during the synchronous design pass — a choice made in code, in a chat, on a…

    171 GitHub stars~2.6k tokensUpdated 1 mo ago
    Auto-check passed
  • Tasks

    genkovich/sdd

    A skill your agent uses to break a designed feature into atomic, ≤1-day tasks with a dependency graph, a per-task Definition of Done, and a machine-readable tasks.json that the implement engine…

    171 GitHub stars~4.8k tokensUpdated 1 mo ago
    Auto-check passed
  • API

    genkovich/sdd

    A skill your agent uses to derive the API contract for a feature — an OpenAPI 3.1 document at docs/features/{slug}/contracts/openapi.yaml plus a drift/sync report (and an events doc when the feature…

    171 GitHub stars~4.3k tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Implement

What does Implement do?

A skill your agent uses to implement a feature from its tasks.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task. Implement is an agent skill from genkovich/sdd.json with test-driven development — writes a failing test first, makes it pass, refactors, gates, and commits per task.

When should I use Implement?

Implement fits situations like: implement a feature from its tasks.json with test-driven development — writes a failing test first; commits per task; implement {slug}; code up the tasks for {slug}.

How do I install Implement in Claude Code?

Run `npx skills add genkovich/sdd --skill implement -a claude-code`. Or copy the skill folder (skills/implement in genkovich/sdd) into .claude/skills/implement in your project. Claude Code loads it when a task matches its description.

How do I install Implement in Codex?

Run `npx skills add genkovich/sdd --skill implement -a codex`. Or copy the skill folder (skills/implement in genkovich/sdd) into .agents/skills/implement in your project. Codex loads it when a task matches its description.

Can I use Implement in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add genkovich/sdd --skill implement -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/implement, .gemini/skills/implement, .github/skills/implement and .opencode/skills/implement in your project.

What does Implement need to run?

SKILL.md names no scripts, command-line tools or credentials: Implement is instructions for the agent only. Our summary lists: Docker.

Does Implement access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Implement safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Implement use?

Implement is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Implement use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 9.3k tokens, read only when the agent opens those files.

What are the alternatives to Implement?

Skills that share tags, products or a category with Implement: TDD Workflow (hellangleZ/burn-in-cceverywhere-ralph, 112 stars), TDD Methodoly Expert (thedaviddias/skill-check, 190 stars), TDD (DanMcInerney/architect-loop, 626 stars) and TDD Workflow (affaan-m/ECC, 274k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Implement?

genkovich (a GitHub user) maintains it in genkovich/sdd, which has 171 GitHub stars. The repository holds 21 skills in this directory. The repository was last updated on September 5, 2026.

Source: genkovich/sdd on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.