What is the Iron Law of this TDD skill?

The Iron Law dictates that no production code should be written without first having a failing test that verifies the intended behavior. If code is written first, it must be deleted.

How does this skill handle the 'Red' phase?

It requires writing a minimal test and verifying that it fails for the expected reason (missing feature/bug) rather than a syntax error or typo.

Can I use this skill for existing projects without tests?

Absolutely. You can use the TDD cycle to add new features or fix bugs in existing codebases, gradually improving test coverage and code reliability.

Why is writing the test first better than writing it after?

Writing tests first defines the desired behavior and ensures the test actually works. Tests written after code are often biased by the implementation and may pass even if they don't verify the logic correctly.

Test-Driven Development (TDD)

Name: Test-Driven Development (TDD)
Author: Jst-Well-Dan

byJst-Well-Dan

Security & Testing

Enforces a strict Red-Green-Refactor cycle to ensure code reliability by requiring failing tests before any implementation code is written.

About

This skill implements a rigorous Test-Driven Development (TDD) workflow for Claude, adhering to the 'Iron Law' that no production code should be written without a failing test first. It guides the development process through the essential Red-Green-Refactor stages, ensuring that tests are meaningful, code is minimal, and design remains clean. By preventing the common 'tests-after' bias, this skill helps developers build more robust, maintainable software while effectively eliminating regressions and over-engineering during the feature development or bug-fixing process.

Key Features

Heuristics to identify and correct common TDD rationalizations
Guidance on writing minimal production code to satisfy requirements
0 GitHub stars
Strict Red-Green-Refactor cycle enforcement
Mandatory verification of test failures to prevent false positives
Integrated refactoring steps to maintain clean code architecture

Use Cases

Safe refactoring of complex logic while maintaining existing functionality
Fixing software bugs by first reproducing them with failing test cases
Building new features with high confidence and documented behavior

About

Key Features

Heuristics to identify and correct common TDD rationalizations
Guidance on writing minimal production code to satisfy requirements
0 GitHub stars
Strict Red-Green-Refactor cycle enforcement
Mandatory verification of test failures to prevent false positives
Integrated refactoring steps to maintain clean code architecture

Use Cases

Safe refactoring of complex logic while maintaining existing functionality
Fixing software bugs by first reproducing them with failing test cases
Building new features with high confidence and documented behavior