TDD Workflow
hellangleZ/burn-in-cceverywhere-ralph
A skill your agent uses when writing new features, fixing bugs, or refactoring code.
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.
$ npx skills add genkovich/sdd --skill implement -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install genkovich/sdd implement --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ 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-srcUse ~/.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/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .claude/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/genkovich/sdd/tree/main/skills/implementType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add genkovich/sdd --skill implement -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install genkovich/sdd implement --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/implement .agents/skills/implement && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .agents/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add genkovich/sdd --skill implement -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install genkovich/sdd implement --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/implement .cursor/skills/implement && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .cursor/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/genkovich/sdd.git --path skills/implement--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add genkovich/sdd --skill implement -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install genkovich/sdd implement --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/implement .gemini/skills/implement && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .gemini/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install genkovich/sdd implementInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add genkovich/sdd --skill implement -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/implement .github/skills/implement && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .github/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add genkovich/sdd --skill implement -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install genkovich/sdd implement --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/genkovich/sdd.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/implement .opencode/skills/implement && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "implement" agent skill from https://github.com/genkovich/sdd/tree/main/skills/implement into .opencode/skills/implement/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "implement", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
implementA 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. 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.
10 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 4403913. It shows what the files ask for, not the result of running them.
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.
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.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
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.
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.
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.
The full file from genkovich/sdd at commit 4403913, republished under its MIT licence (© genkovich). 1,036 words, ~2,509 tokens.
.claude/skills/implement/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.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/.
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).
<slug> — feature slug.docs/features/<slug>/tasks.json. Missing → «run tasks <slug> first».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/..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.tasks.json exists and parses; load the upstream artifacts list. Detail → ./references/inputs.md..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../references/command-detection.md.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)../references/decision-tree.md). Apply the guards.Workflow script (DAG → Kahn phases → fan-out pipeline). → ./references/team-exec.md / ./references/workflow-exec.md.mode=<…> tdd=<…> isolation=<…> parallel=<n> integration=<…>. The user sees exactly how the engine will behave before it acts../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.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.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.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.
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).
tasks.json is either committed (test-first, gate-clean, SDD-Task/SDD-AC trailers) or explicitly reported as dropped/blocked with the reason.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.../_shared/self-check.md); its results are reported in the handoff.tdd: false, which warns).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
SKILL.md and 8 other files (references) in skills/implement of genkovich/sdd.
Open the folder on GitHubat commit 4403913
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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Implement this skillgenkovich/sdd | 171 | — | ~2.5k | Automated safety check: Pass | MIT | |
| TDD WorkflowhellangleZ/burn-in-cceverywhere-ralph | 112 | 11 repos | ~2.4k | Automated safety check: Pass | None | |
| TDD Methodoly Expertthedaviddias/skill-check | 190 | — | ~2.2k | Automated safety check: Pass | MIT | |
| TDDDanMcInerney/architect-loop | 626 | — | ~730 | Automated safety check: Pass | MIT | |
| TDD Workflowaffaan-m/ECC | 274k | 1 repos | ~2.6k | Automated safety check: Pass | MIT | |
| Fixjvm-skills/jvm-skills | 140 | — | ~695 | Automated safety check: Pass | Apache-2.0 |
hellangleZ/burn-in-cceverywhere-ralph
A skill your agent uses when writing new features, fixing bugs, or refactoring code.
thedaviddias/skill-check
A skill your agent uses when implementing features or fixing bugs with strict Test-Driven Development (TDD).
DanMcInerney/architect-loop
Test-driven development for factory builders. An agent skill from DanMcInerney/architect-loop.
affaan-m/ECC
Yeni özellikler yazarken, hata düzeltirken veya kod refactor ederken bu skill'i kullanın.
jvm-skills/jvm-skills
Fix a bug or missing feature using TDD — write failing test first, then fix, refactor, verify, beautify.
dzhalaevd/Donatello
Use as a workflow overlay when implementing any feature, bugfix, refactor, or behavior change before writing production code
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…
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…
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…
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…
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…
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…
Categories
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.
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}.
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.
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.
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.
SKILL.md names no scripts, command-line tools or credentials: Implement is instructions for the agent only. Our summary lists: Docker.
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.
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.
Implement is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
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.
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.
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.