test-driven-development

To implement test-driven development for new features, write a failing test first, then create minimal code to pass it, and finally refactor to optimize. This structured red-green-refactor cycle ensures robust, reliable code with thorough test coverage.

The red-green-refactor cycle in TDD is a structured process where you write a failing test, implement minimal code to make it pass, and then clean up the design through refactoring. It enforces the iron law of no production code without a failing test first.

Yes, you can use test-first development for bug fixes and refactoring. The Skill applies TDD principles across all development stages, requiring you to write a failing test that reproduces the bug before implementing the fix to ensure code quality.

Test-driven development improves code quality and reduces bugs by enforcing continuous refactoring and thorough test coverage. By writing tests before implementation code, you foster better software design and catch failures fast throughout the development process.

The best way to start writing failing tests is to define the desired behavior first. You write a test that fails because the feature does not exist, implement the minimal code to pass that test, and then refactor to optimize the software.

You should reconsider test-first development if your context cannot support the iron law of no production code without a failing test. TDD requires strict adherence to writing tests first, failing fast, and continuous refactoring, which may not suit exploratory prototypes.