tdd

Solid

Write code through a disciplined, BDD-framed Test-Driven Development loop: build a behavior test list, then drive each behavior through red-green-refactor with an enforced observed-failure gate. Use when the user wants to implement, build, or write code test-first, "do TDD", follow "red-green-refactor", drive code from tests, or grow a feature behavior-by-behavior with tests leading. This skill writes and changes code; it does not produce a test plan document (use test-planning), review or audit existing code (use code-review), specify what a feature should do (use plan-a-feature), or find the root cause of a bug (use investigate).

Testing & QA 66 stars 5 forks Updated today MIT

Install

View on GitHub

Quality Score: 88/100

Stars 20%
61
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

## Project Context - git installed: !`git --version 2>/dev/null` - current branch: !`git branch --show-current 2>/dev/null` - CLAUDE.md: !`find . -maxdepth 1 -name "CLAUDE.md" -type f` - project-discovery.md: !`find . -maxdepth 3 -name "project-discovery.md" -type f` ## Constraints (read before anything else) This skill writes production and test code in your working tree. It is an execution skill, not a document generator. These constraints shape every step and override any instinct to move faster. - **The observed-failure gate is load-bearing.** No production-code change until a test has been run and observed to fail for the intended reason in this loop. A test that passes on first run is a stop-and-diagnose signal, not progress. This single rule is what separates real TDD from TDD-flavored code. The verbatim Three Laws and Canon TDD steps it derives from are in [references/tdd-loop.md](references/tdd-loop.md); pull that reference when a step needs the canon or the implementation gears. - **Two hats.** Never refactor while any test is red. See [references/tdd-loop.md](references/tdd-loop.md) for the canonical statement. - **One behavior at a time.** Exactly one test list item becomes one runnable test per loop. Newly discovered scenarios are written to the list and deferred, never implemented in the current loop. - **BDD framing.** Tests describe observable behavior, named in the project's existing test-naming convention, asserting outcomes through t...

Details

Author
testdouble
Repository
testdouble/han
Created
3 weeks ago
Last Updated
today
Language
Shell
License
MIT

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Listed

tdd

Implement features using Test-Driven Development (TDD) with the red-green-refactor cycle. Use when the user asks to implement X using TDD, write this with TDD, use TDD, TDD this feature, red-green-refactor, or test-first. Requires Write and Edit access — invoke only in a context that can modify source and test files.

0 Updated today
brenpike
Code & Development Listed

tdd

Guides test-driven development — decompose a feature or bug fix into behaviors, then cycle through Red (failing test) → Green (minimal implementation) → Refactor for each one. Requires /optimus:init and working test infrastructure. Use when starting a new feature or bug fix with test-first discipline.

57 Updated yesterday
oprogramadorreal
Testing & QA Solid

test-driven-development

Use when implementing any feature or bugfix, before writing implementation code

233 Updated today
jamditis
Testing & QA Listed

tdd

Guided TDD workflow — plan, tracer bullet, incremental RED-GREEN

4 Updated today
lwalden
Testing & QA Listed

tdd-patterns

Guide test-driven development through the mandatory Red-Green-Refactor cycle (failing test before code), enforce test quality (one behavior per test, real code over mocks, no implementation-detail testing), and enforce test runner discipline (run mode, no watch mode). Use when implementing features or fixing bugs (with `testing.tddMode='enforce'` blocking implementation without a failing test). This skill MUST be consulted because test-first is the primary quality enforcement point; tests that pass on first write are suspect (likely testing the wrong thing).

5 Updated yesterday
synaptiai