test-driven-development

Test-driven development requires writing a failing unit test that outlines the desired behavior before implementing any code. You then write the minimal code required to pass that test and finally refactor for clarity while preserving behavior.

The red-green-refactor cycle is a test-driven development workflow where you first write a failing test, implement minimal code to make it pass, and then refactor the code for clarity. This iterative process guides incremental design and catches regressions early.

When fixing bugs, you should first write a failing unit test that specifically reproduces the bug. Implement the code fix to turn the test green, ensuring your refactoring preserves the existing behavior while satisfying the new test requirements.

Test-driven development applies across various languages and stacks for adding features, fixing bugs, and refactoring. The practice forces failing tests before coding, making it adaptable to any environment that supports unit tests and iterative development.

You should avoid test-driven development during refactoring if you cannot first establish passing tests that verify the existing behavior. The refactoring phase requires a green test suite to ensure you preserve functionality while improving code clarity and reliability.

Writing failing tests before coding establishes tests as a specification for your desired behavior, catching regressions early. This approach forces you to implement only the minimal code necessary to pass the test, preventing over-engineering and guiding incremental design.