tdd

Guide red-green-refactor loops with tests before implementation.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Test-driven development helps teams verify software behavior through tests before implementation, reducing regressions and enabling safer, more maintainable code.

Core Features & Use Cases

  • Red-Green-Refactor Loop: guides the short, repeatable cycle of writing a failing test, making it pass, then refactoring.
  • Integration-Style Tests: emphasizes end-to-end validation through public interfaces, not internal details.
  • Incremental Delivery: supports vertical slices and tracer bullets to minimize waste during feature work.

Quick Start

Start by writing one end-to-end RED test and then implement the minimum code to pass it.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I start writing tests before implementation using TDD?

Start TDD by writing one failing end-to-end RED test through a public interface, then implement the minimum code required to pass it. This validates software behavior incrementally before full implementation.

What is the red-green-refactor cycle in test-driven development?

The red-green-refactor cycle is a short, repeatable loop where you write a failing test, write the minimum code to make it pass, then refactor safely. It enforces lightweight, deterministic workflows.

Should I write integration tests or unit tests for public APIs?

Integration tests are emphasized to validate end-to-end behavior through public interfaces rather than testing internal details. This ensures observable behavior works correctly across the system.

How do I minimize waste during feature development with incremental delivery?

Minimize waste by delivering vertical slices and using tracer bullets to guide feature work. This supports incremental delivery and reduces regressions through observable behavior validation.

When should I not use test-driven development for software engineering?

TDD may not suit contexts lacking clear public interfaces or deterministic workflows. It enforces testing observable behavior, so highly exploratory code without defined endpoints may face constraints.