tdd_skill

Overview

This skill guides developers through test-driven development using the red-green-refactor loop, focused on behavior-first, integration-style tests. It emphasizes vertical tracer-bullet cycles: one failing test, minimal implementation to pass, then refactor. Use it to build features or fix bugs with test-first discipline.

How this skill works

I steer you through planning, writing a single end-to-end test (the tracer bullet), implementing the smallest amount of code to make that test pass, and then refactoring safely. Tests should exercise public interfaces and describe observable behavior so they survive internal changes. The loop repeats until the targeted behaviors are covered, then you run a disciplined refactor step with tests green.

When to use it

• Starting a new feature and you want test-first development
• Fixing a bug and verifying behavior before changing code
• When you need integration-style tests that exercise public APIs
• When you want to avoid speculative or implementation-coupled tests
• When you need a repeatable red→green→refactor workflow for quality

Best practices

• Write tests against the public interface only; avoid mocking internal collaborators
• Do one test → one implement → repeat; avoid writing many tests up front
• Keep each implementation minimal to satisfy the current test—no speculative features
• Use tracer bullets: start with a single end-to-end test that validates the path
• Only refactor after tests are green and run tests after each refactor step

Example use cases

• Add checkout flow: write a test that a user can complete checkout, implement minimal handlers, then refactor
• Fix flaky failure: write a failing integration test that reproduces the bug, implement fix, keep tests focused on behavior
• Expose a new public API: design the interface first, write tests for expected behavior, implement incrementally
• Convert brittle unit tests to integration-style tests that validate end-to-end behavior
• Iteratively develop complex logic behind a small interface using deep modules