tdd

Test-driven development using red-green-refactor cycles starts by writing a failing public-interface test, implementing minimal code to pass, and refactoring only when green. This enforces observable behavior and prevents scope creep during feature work.

Writing failing tests against the public interface first in TDD pins behavior via the contract rather than internal details. This approach guides design decisions and delivers working code early by focusing on observable outcomes.

Yes, TDD works for vertical slice feature implementation by driving one feature slice at a time through red-green-refactor loops. Each slice produces measurable test outcomes and supports iterative edge case handling with guardrails.

You should refactor code during test-driven development only when tests are green. This continuous improvement phase allows safe code restructuring after minimal implementation passes, preventing regression while maintaining observable behavior.

The best way to prevent scope creep during TDD cycles is applying guardrails that enforce writing one failing test at a time, implementing minimal code to pass, and iterating on edge cases only after green. This keeps feature work focused.

Yes, test-driven development works for bug fixes with clear external contracts and observable behavior. Applied at the task level, it guides fixes by first writing a failing test that reproduces the bug before minimal implementation.