{"enrichment":{"faq":[{"a":"TDD Mastery teaches that you write a failing test before any production code. In the red phase, you observe the test fail to confirm it's testing the right behavior. In the green phase, you write minimal code to pass that test. In the refactor phase, you improve the code while keeping tests green. This sequence is non-negotiable\u2014TDD Mastery rejects any production code written before its test exists and has failed.","q":"How do you write tests first in the red-green-refactor cycle?"},{"a":"TDD Mastery's workflow for beginners is: (1) Write a failing test and watch it fail; (2) Write minimal code to make it pass; (3) Refactor while keeping tests green; (4) Repeat. This red-green-refactor cycle enforces strict test-first discipline. Each cycle should be small and focused. TDD Mastery emphasizes that skipping the failing test observation step or writing code before tests violates the iron law of test-first development.","q":"What is the TDD workflow for beginners?"},{"a":"TDD Mastery requires watching your test fail first because it proves your test is actually testing something. If a test passes before you write code, it's not testing the new behavior\u2014it's a false positive. Observing the red phase confirms your test will catch regressions and validates your test logic. This verification step is core to TDD Mastery's iron law: no production code without a preceding, observed-failing test.","q":"Why should you watch a test fail before coding?"},{"a":"TDD Mastery fixes bugs by first writing a failing test that reproduces the bug, then fixing the code to pass that test. This ensures the bug is captured and won't resurface. The test becomes a permanent guard. TDD Mastery rejects hotfixes or patches written without this test-first protocol, maintaining quality standards and testing infrastructure rigor across all code changes.","q":"How does TDD Mastery handle bug fixes using test-first protocol?"},{"a":"TDD Mastery supports setup with Vitest, Jest, or pytest depending on your language. The skill emphasizes that testing infrastructure must be in place before development begins. It also covers contract-first testing with MSW handlers for API mocking. TDD Mastery implements quality standards by ensuring your test framework, runners, and coverage tools are configured to enforce the red-green-refactor cycle and reject code without preceding tests.","q":"What testing infrastructure does TDD Mastery recommend?"},{"a":"TDD Mastery helps avoid writing code before tests, skipping the red phase verification, writing overly complex tests, and refactoring without green tests. It teaches that minimal code to pass tests prevents over-engineering. TDD Mastery also emphasizes clear test names, edge case coverage, and a verification checklist for each cycle. The skill enforces the iron law with no exceptions: every production function must have a failing test written and observed first.","q":"What common TDD mistakes does TDD Mastery help you avoid?"}],"shadow_tags":["test-first-discipline","red-green-refactor","verification-protocol","minimal-implementation","quality-gates","coverage-standards","bug-reproduction-testing","anti-pattern-detection"],"summary_rewrite":"TDD Mastery enforces the iron law of test-first development: write a failing test, verify it fails, implement minimal code to pass, then refactor. The skill drills the red-green-refactor cycle with no exceptions, rejecting any production code written before its corresponding test exists and has been observed failing."},"files":[{"bytes":8707,"path":"skills/tdd-mastery/SKILL.md","sha256":"deed8dce6e28c9f61522ec05826a5a333648b2d745589ca9f96be6256926640b","url":"https://skillfed.io/files/xenitV1/claude-code-maestro/tdd-mastery/b9b77f2a/SKILL.md"}],"id":"xenitV1/claude-code-maestro/tdd-mastery","links":{"html":"https://skillfed.io/xenitV1/claude-code-maestro/tdd-mastery","md":"https://skillfed.io/xenitV1/claude-code-maestro/tdd-mastery.md","repo":"https://github.com/xenitV1/claude-code-maestro"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":34,"language":"JavaScript","last_updated":"2026-01-24","license":"MIT","name":"tdd-mastery","publisher":"xenitV1","stars":230},"relations":{"similar":[{"id":"xenitV1/claude-code-maestro/verification-mastery"},{"id":"eyadsibai/ltk/test-driven-development"},{"id":"parcadei/Continuous-Claude-v3/tdd"},{"id":"Wide-Moat/open-computer-use/test-driven-development"},{"id":"ShaftHQ/SHAFT_ENGINE/test-driven-development"},{"id":"family3253/skill/superpowers-test-driven-development"},{"id":"getcrew44/crew44/test-driven-development"},{"id":"rpamis/comet/test-driven-development"},{"id":"obra/superpowers-skills/test-driven-development"},{"id":"beita6969/ScienceClaw/test-driven-development"}]},"slug":{"owner":"xenitV1","repo":"claude-code-maestro","skill":"tdd-mastery"},"version":"b9b77f2a"}