tdd-process

Enforce a test-driven development state machine across red-green-refactor cycles.

Updated Mar 3, 2026
One-click install
npx skills add https://github.com/igoyetche/send-to-kindle --skill tdd-process-igoyetche
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-process
Source: https://github.com/igoyetche/send-to-kindle/tree/main/.claude/skills/tdd-process
Command: npx skills add https://github.com/igoyetche/send-to-kindle --skill tdd-process-igoyetche

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill enforces rigorous Test-Driven Development (TDD) practices, ensuring code is developed with a strong foundation of failing tests, minimum implementation, and thorough verification, preventing regressions and improving code quality.

Core Features & Use Cases

  • Strict State Machine: Guides development through PLANNING, RED, GREEN, REFACTOR, and VERIFY states with mandatory announcements and evidence.
  • Rule Enforcement: Implements 11 critical TDD rules, including meaningful failures, minimum implementation, and post-condition validation.
  • Use Case: When starting a new feature, explicitly activate this skill to ensure a test-first approach, leading to more robust and maintainable code.

Quick Start

Use the tdd-process skill to test-drive the implementation of a new user authentication module.

Frequently Asked Questions about tdd-process

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

FAQPage Schema
How do I enforce a strict test-driven development workflow when writing new code?

A strict test-driven development workflow is enforced by operating as a state machine that guides you through PLANNING, RED, GREEN, REFACTOR, and VERIFY states. It requires mandatory state announcements and evidence-based transitions to ensure rigorous adherence to TDD principles.

What are the core rules of the red-green-refactor cycle?

The red-green-refactor cycle is governed by 11 core TDD principles, including achieving meaningful failures, writing minimum implementation code, and performing post-condition validation. These rules ensure code is developed with a strong foundation of failing tests and thorough verification.

How do I prevent code regressions during refactoring?

To prevent code regressions during refactoring, you must enter the mandatory REFACTOR state within the TDD state machine, which requires evidence-based transitions and post-condition validation before completing the cycle. This ensures code quality is maintained without breaking existing functionality.

Can I skip the test-writing phase if I already know the implementation?

No, skipping the test-writing phase violates the strict state machine, which requires passing through the RED state with meaningful failures before moving to GREEN. This rigorous adherence to TDD principles prevents regressions and ensures a strong foundation of failing tests.

When should I use a state machine approach for my development workflow?

A state machine approach for your development workflow should be used when starting a new feature to guarantee a test-first approach. It is ideal for teams needing strict rule enforcement and mandatory evidence for every state transition to improve code quality.

What happens if my tests fail unexpectedly during the development cycle?

If tests fail unexpectedly during the development cycle, the state machine enters the BLOCKED state, halting progress until the issue is resolved. This constraint ensures all actions are validated and prevents moving forward without passing tests.