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.