tdd

Guide AI through RED and SUPER GREEN TDD phases with failing tests.

4|Updated Oct 27, 2014
One-click install
npx skills add https://github.com/B-Galati/dotfiles --skill tdd-b-galati
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/B-Galati/dotfiles/tree/main/claude/skills/tdd
Command: npx skills add https://github.com/B-Galati/dotfiles --skill tdd-b-galati

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill automates the Test-Driven Development (TDD) workflow, ensuring clean, production-ready code is written iteratively without a "quick and dirty" phase.

Core Features & Use Cases

  • Iterative Development: Guides the AI through writing failing tests first (RED phase) and then implementing the production-ready code (SUPER GREEN phase).
  • True Red Enforcement: Distinguishes between compilation errors and actual behavior failures, ensuring tests are truly failing on behavior.
  • Architectural Guidance: Provides a moment for user input on architectural patterns before implementation.
  • Use Case: When developing a new feature, use this Skill to ensure robust test coverage and clean code from the outset, following the Red -> Super Green methodology.

Quick Start

Use the tdd skill to write a failing test for the new user authentication feature.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I implement a Test-Driven Development workflow without writing quick and dirty code?

Test-Driven Development can be automated to ensure production-ready code by enforcing a strict workflow: writing failing behavioral tests first, then iteratively implementing the final code without a transitional dirty phase.

What is a true red failing test in TDD?

A true red failing test in TDD is a behavioral failure rather than a compilation or syntax error. This ensures the test is actually validating the intended logic before any implementation code is written.

How do I guide an AI through the red green refactor cycle?

You guide an AI through the red green refactor cycle by having it write a failing test first, then providing architectural guidance before it implements the production-ready code to make the test pass.

Does this TDD approach allow architectural input before implementation?

Yes, this TDD approach includes optional architectural guidance moments, allowing you to define architectural patterns for the AI before it generates the production-ready implementation code.

Can I use TDD to develop new features with robust test coverage from the start?

Yes, you can use TDD to develop new features by writing a failing test for the feature first, ensuring robust test coverage and clean code are established from the very outset of implementation.