tdd-red-phase

Create failing tests before implementation to enforce the TDD Red phase.

1|Updated Jan 15, 2026
One-click install
npx skills add https://github.com/pagerguild/guilde-lite --skill tdd-red-phase
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-red-phase
Source: https://github.com/pagerguild/guilde-lite/tree/main/marketplace/plugins/tdd-automation/skills/tdd-red-phase
Command: npx skills add https://github.com/pagerguild/guilde-lite --skill tdd-red-phase

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Teams practicing Test-Driven Development often skip the disciplined Red phase, leading to ambiguous requirements and fragile implementations. This skill guides you to start by writing a failing test that defines the expected behavior before any code exists, ensuring a clear contract and preventing premature optimizations.

Core Features & Use Cases

  • Red-phase guidance: Create and organize failing tests to drive feature design and validation.
  • AAA test pattern enforcement: Ensure tests have Arrange-Act-Assert structure and clear naming.
  • Phase tooling: Provide prompts and lightweight scripts to manage Red-Green transitions and test runs.

Quick Start

Ask the AI to craft a failing test that represents the next feature and outline the Red phase workflow for your project.

Frequently Asked Questions about tdd-red-phase

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

FAQPage Schema
How do I write a failing test to enforce the Red phase in TDD?

To enforce the TDD Red phase, write a failing test that defines expected behavior before any implementation code exists. This approach establishes a clear contract and prevents premature optimizations by ensuring requirements are unambiguous.

Why does my test-driven development workflow skip the disciplined Red phase?

TDD workflows often skip the disciplined Red phase due to ambiguous requirements, leading to fragile implementations. Creating a failing test first codifies test naming and phase transitions, ensuring a clear contract before writing code.

How do I structure failing tests using the AAA pattern for new feature development?

Structure failing tests using the Arrange-Act-Assert pattern with clear naming to drive new feature development. This ensures tests have a distinct setup, execution, and verification phase before any implementation logic is written.

Can I apply the TDD Red phase workflow across different programming languages and teams?

Yes, you can apply the TDD Red phase workflow across languages and teams. It provides lightweight scripts to run tests and guide progression, codifying test naming and phase transitions independently of specific programming languages.

What is the best way to manage Red-Green transitions during test-driven development?

The best way to manage Red-Green transitions is by using phase tooling that provides prompts and lightweight scripts. These tools guide progression by running tests and verifying that the Red phase fails correctly before moving to Green.

When do I need to create a failing test before writing implementation code?

You need to create a failing test before writing implementation code whenever you start new feature development. This validates the expected behavior and establishes a clear contract, preventing ambiguous requirements and fragile code.