test-driven-development

Use when writing new functions, adding features, fixing bugs, or refactoring by applying TDD principles - write failing tests before implementation code, make them pass, then refactor.

⭐47stars🔀5forks📁View on GitHub🕐Updated Jan 2, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill implements the Test-Driven Development (TDD) methodology to enhance software reliability and code quality. By following the Red-Green-Refactor cycle, it ensures that every new feature, bug fix, or refactoring effort is backed by automated tests, significantly reducing technical debt and preventing regressions in complex codebases.

Use Cases

  • New Feature Development: Implementing robust features by defining expected behavior through failing tests before writing any production code.
  • Bug Fixing and Regression Testing: Reproducing reported bugs with specific test cases to ensure the fix is effective and prevents the issue from reoccurring.
  • System Refactoring: Safely restructuring existing code by using a comprehensive test suite as a safety net to maintain functional integrity.
  • API Design and Validation: Using a test-first approach to design clean and intuitive APIs by simulating consumer interactions early in the development process.
nametest-driven-development
descriptionUse when writing new functions, adding features, fixing bugs, or refactoring by applying TDD principles - write failing tests before implementation code, make them pass, then refactor.

Test-Driven Development (TDD)

Red → Green → Refactor cycle for all code changes.

The TDD Cycle

  1. RED: Write failing test
  2. GREEN: Write minimal code to pass
  3. REFACTOR: Improve code quality

Repeat for each requirement

When to Apply TDD

✅ Always use TDD for:

  • New functions/methods
  • New features
  • Bug fixes (reproduce first)
  • Refactoring existing code
  • API changes

❌ Skip TDD for:

  • UI styling tweaks
  • Configuration changes
  • Documentation updates

Process

1. Write Failing Test First

# Start with test
test "calculates total with tax" do
  result = Calculator.calculate_total([100, 200])
  assert Money.equal?(result, Money.new(:USD, 324))
end

# Run test - should FAIL
mix test

2. Implement Minimal Code

# Just enough to pass
def calculate_total(prices) do
  prices |> Enum.sum() |> Kernel.*(1.08) |> Money.new(:USD)
end

3. Refactor

Extract constants, improve naming, etc.

Test Patterns by Stack

Backend (Elixir)

  • File: test/path/module_test.exs
  • Pattern: apps/api/test/your_app/task/task_test.exs

Frontend (TypeScript)

  • File: ComponentName.test.tsx
  • Pattern: mobile/libraries/atorasu/atoms/Button/Button.test.tsx

Critical Rules

  • Tests MUST fail first (verify test works)
  • One test per requirement
  • Test behavior, not implementation
  • Run FULL test suite before commit
  • NEVER skip failing tests

Common Pitfalls

  • Writing implementation before test
  • Tests that pass without implementation (false positive)
  • Testing implementation details instead of behavior
  • Not running test to verify it fails first

Verification

# Backend
mix test path/to/test.exs

# Frontend
yarn test path/to/test.tsx