tdd

# TDD Red. Green. Refactor. In that order, every time. ## Hard Rules - No production code without a failing test first. - If production code was written before its test, delete it and start over with a failing test. - Never skip the red step. A test that has never failed proves nothing. ## Cycle For each unit of behavior: 1. **Red** — Write a test for the next behavior. Run it. It must fail. Read the failure message — it should describe the missing behavior. 2. **Green** — Write the minimum production code to make the test pass. Nothing more. Run the test. Apply the `verify` skill. 3. **Refactor** — Clean up both test and production code. Run the test again. Still green? Done. Apply the `verify` skill. Then pick the next behavior and repeat. ## Rules for Each Step **Red:** - Test one behavior, not one function. Name the test after what the system should do, not what the function is called. - The test must fail for the right reason — a missing method, wrong return value, unmet condition. Not a syntax error or import failure. - If the test passes immediately, it's not testing new behavior. Delete it or pick a different behavior. **Green:** - Write the simplest code that passes. Hardcode if needed — the next test will force generalization. - Do not add code "while you're in there." If it's not required by a failing test, it doesn't exist yet. - Do not refactor during green. Pass first, clean second. **Refactor:** - Remove duplication between test and production code. - Extract only when you see real duplication, not predicted duplication. - Tests must still pass after every refactor move. Run them after each change. ## Anti-Patterns | Pattern | Problem | Fix | |---|---|---| | Test-after | Code shapes the test instead of the other way around | Delete the code, write the test first | | Testing internals | Tests break on refactor, not on behavior change | Test public behavior only | | Giant red step | Multiple behaviors in one test | One assertion per behavior | | Gold-plating green | Adding code no test requires | Remove untested code | | Skipping refactor | Tech debt accumulates immediately | Refactor before the next red | | Mock-heavy tests | Tests pass but real code fails | Prefer real dependencies, mock at boundaries only | ## Red Flags and Rationalizations | Rationalization | Why It's Wrong | Do Instead | |---|---|---| | "This is too simple to test first" | Simple code still needs a spec | Write the test — it'll be fast | | "I'll add the test right after" | You won't, and the code will shape the test | Test first, always | | "I need to see the design first" | The test IS the design | Let the test drive the interface | | "Mocking is too hard for this" | Difficulty mocking signals tight coupling | Fix the design, then test | | "The test would be identical to the implementation" | Then you're testing internals | Test the behavior from the outside | ## Memory Integration After completing a TDD session, store reusable test patterns (setup, assertions, fixtures): `npx ai-devkit@latest memory store --title "<pattern>" --content "<details>" --tags "tdd,testing"`