tdd

Implement a red-green-refactor TDD workflow with integration-style tests.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/tojoolivier/claude-config --skill tdd-tojoolivier
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/tojoolivier/claude-config/tree/main/skills/tdd
Command: npx skills add https://github.com/tojoolivier/claude-config --skill tdd-tojoolivier

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Test-driven development helps teams deliver robust software by validating behavior through public interfaces, reducing fragility during refactors and feature changes.

Core Features & Use Cases

  • Structured workflow: planning, tracer bullets, one-red-one-green increments, and deliberate refactoring to maintain clean interfaces.
  • Emphasis on integration-style tests that describe observable behavior, ensuring tests survive internal changes.
  • Use Case: starting a new feature, write a failing test, implement the minimal code to pass, then iteratively improve with refactoring while preserving behavior.

Quick Start

Begin with one failing test and implement the minimal code to make it pass.

Frequently Asked Questions about tdd

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a test-driven development workflow for new feature development?

Test-driven development workflow is implemented through planning, tracer bullets, and one-red-one-green increments to build features. You write a failing test, implement minimal code to pass, then systematically refactor to maintain clean public interfaces.

What is the red-green-refactor cycle and how does it improve code quality?

Red-green-refactor is a disciplined TDD cycle where you write a failing test, implement minimal passing code, then systematically refactor. It improves quality by driving observable behavior through public interfaces, ensuring tests survive internal changes.

How do I write integration-style tests that validate observable software behavior?

Integration-style tests validate observable behavior by interacting with public interfaces rather than internal implementations. This testing approach ensures your tests remain robust and survive internal refactoring or structural code changes.

Can I use this TDD workflow for bug fixes as well as new features?

Yes, this TDD workflow applies to both feature development and bug fixes. It enforces structured planning and incremental red-green cycles to drive reliable behavior validation through public interfaces across various software engineering projects.

When should I use integration-style testing instead of isolated unit tests?

Use integration-style testing when you need to describe observable behavior and ensure tests survive internal refactoring. This approach reduces test fragility during feature changes by validating behavior through public interfaces rather than internal implementations.

What is the best way to start a new feature using disciplined TDD?

The best way to start a new feature with disciplined TDD is to begin with one failing test and implement the minimal code to make it pass. Then iteratively improve the design through deliberate refactoring while preserving behavior.