tdd

Apply red-green-refactor cycles to code with clean public interfaces.

8|1|Updated Apr 10, 2026
One-click install
npx skills add https://github.com/max4c/skills --skill tdd-max4c
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/max4c/skills/tree/main/skills/tdd
Command: npx skills add https://github.com/max4c/skills --skill tdd-max4c

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Test-driven development, done right: one test, one implementation, repeat; tests describe behavior through public interfaces, not implementation details.

Core Features & Use Cases

  • Public-interface focus: tests verify observable behavior rather than internal structure.
  • Vertical-slice tracer bullets: end-to-end validation of features with minimal scope per cycle.
  • When NOT to use TDD: guidance on UI code, animations, or certain system-framework interactions where smoke tests or verification are more effective.

Quick Start

Apply tracer bullets by writing a single, end-to-end test for a public interface, then implement the minimal code to pass and commit.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I apply test-driven development to verify public interfaces?

Test-driven development for public interfaces involves writing one test describing observable behavior, then implementing minimal code to pass. This red-green-refactor cycle ensures tests validate behavior through public APIs rather than internal implementation details.

What is the vertical-slice approach in TDD?

Vertical-slice TDD uses tracer bullets to validate features end-to-end with minimal scope per cycle. You write a single test for a public interface, implement the code to pass, and commit, ensuring continuous end-to-end validation throughout development.

When should I not use TDD for my code?

TDD should not be used for UI code, animations, or certain system-framework interactions. Smoke tests or direct verification are more effective in these scenarios where behavioral outcomes are difficult to capture through public-interface testing.

Can I use TDD for parsers, serializers, and CLI commands?

Yes, TDD targets common components like parsers, serializers, services, data models, and CLI commands. These components typically have clean public interfaces, making them ideal for disciplined test-driven development using one-test-one-implementation cycles.

What's the best way to structure modules for TDD?

Deep module structure is emphasized for TDD, where tests verify observable behavior through public interfaces rather than internal structure. This approach maintains one-test-one-implementation discipline while ensuring modules expose clean APIs.