tdd

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

8|1|Updated Apr 10, 2026

Search Tags:#testing #tdd #red-green-refactor #quality-assurance #software-engineering #vertical-slice #public-interfaces

Ready to run

npx skills add https://github.com/max4c/skills --skill tdd-max4c

💬 Prompt for ChatGPT / Claude Chat▼

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.