tdd-workflows-tdd-green

Implement minimal code that makes failing tests pass in the TDD green phase.

2|Updated Jun 16, 2026
One-click install
npx skills add https://github.com/monang404/lunawave --skill tdd-workflows-tdd-green-monang404
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tdd-workflows-tdd-green
Source: https://github.com/monang404/lunawave/tree/main/.agent/skills/tdd-workflows-tdd-green
Command: npx skills add https://github.com/monang404/lunawave --skill tdd-workflows-tdd-green-monang404

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? When practicing test-driven development, developers often over-engineer implementations or add untested features after writing failing tests. This Skill enforces discipline in the green phase by guiding the implementation of only the minimal code needed to turn failing tests green. ## Core Features & Use Cases - Minimal Implementation Guidance: Applies Fake It, Obvious Implementation, and Triangulation strategies to pass tests with the simplest possible code. - Multi-Language Patterns: Provides green-phase examples for TypeScript, JavaScript/Express, Python/Django, and React components. - Technical Debt Tracking: Records shortcuts and assumptions made during implementation for the subsequent refactor phase. - Use Case: After writing failing tests for a new user service, use this Skill to implement a minimal in-memory version that passes all tests, deferring database integration and validation to the refactor phase. ## Quick Start Ask the AI to implement the minimal code needed to make your failing tests pass, following TDD green phase principles.

Frequently Asked Questions about tdd-workflows-tdd-green

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

FAQPage Schema
How do I implement minimal code to make failing tests pass in TDD?▼

Review the failing tests, identify the smallest change that satisfies the next assertion, and implement only that. Use techniques like Fake It (hard-coded returns), Obvious Implementation, or Triangulation, running tests after each change.

What is the green phase in test-driven development?▼

The green phase is the second step of the red-green-refactor cycle where you write just enough code to make failing tests pass. Correctness matters more than design quality; improvements are deferred to the refactor phase.

When should I use Fake It versus a real implementation?▼

Use Fake It for the first test of a new feature, when dependencies are complex, or when the approach is uncertain. Switch to a real implementation once multiple tests reveal a pattern or faking becomes more complex than real code.

Should I add error handling during the TDD green phase?▼

No, only add error handling if a test explicitly requires it. The green phase prioritizes minimal passing code; validation, edge cases, and robustness belong to later tests and the refactor phase.

What are common anti-patterns in the TDD green phase?▼

Common anti-patterns include gold plating with unrequested features, premature design patterns, performance optimization without metrics, adding new tests mid-phase, and refactoring while implementing. Each adds complexity beyond what tests require.