tdd

Guide Test-Driven Development with red-green-refactor loops and behavior-driven design.

Updated Aug 27, 2026

Search Tags:#code quality #testing #tdd #refactoring #software development #agile

Ready to run

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

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/mnadalc/dotfiles/tree/main/.ai/skills/tdd
Command: npx skills add https://github.com/mnadalc/dotfiles --skill tdd-mnadalc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill guides users through the Test-Driven Development (TDD) process, ensuring software is built with a focus on verifiable behavior and maintainability, reducing bugs and improving code quality.

Core Features & Use Cases

Red-Green-Refactor Loop: Facilitates the core TDD cycle for building features and fixing bugs.
Behavior-Driven Design: Emphasizes testing observable behavior through public interfaces, not implementation details.
Use Case: When starting a new feature, use this Skill to write a failing test, then write the minimal code to pass, and finally refactor, ensuring the feature works as expected from the start.

Quick Start

Use the tdd skill to write a test for the new user registration endpoint.

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 using the test-driven development red-green-refactor loop?▼

The test-driven development red-green-refactor loop starts by writing a failing test that defines desired behavior, then writing minimal code to pass it, and finally refactoring for maintainability. This incremental cycle ensures robust software construction from the start.

What is behavior-driven design in software testing?▼

Behavior-driven design in software testing focuses on verifying observable behavior through public interfaces rather than coupling tests to internal implementation details. This approach ensures tests remain resilient during refactoring and accurately validate functional requirements.

How do I write integration tests that verify observable behavior through public interfaces?▼

Writing integration tests for observable behavior involves interacting with public interfaces to validate functional outcomes, avoiding implementation-detail coupling. This method supports behavior-driven design and ensures tests remain effective during refactoring.

Can I use test-driven development for incremental feature planning and tracer bullet development?▼

Test-driven development supports incremental feature planning and tracer bullet development by guiding the red-green-refactor loop. This methodology allows developers to build end-to-end functionality iteratively, ensuring each feature works as expected from the start.

When should I avoid coupling tests to implementation details during refactoring?▼

You should avoid coupling tests to implementation details during refactoring to maintain test resilience. Behavior-driven testing through public interfaces ensures tests verify observable behavior, allowing internal code improvements without breaking existing test suites.