tdd-hybrid

Route feature work to lightweight or full TDD workflows with mandatory RED/GREEN verification.

4|Updated May 20, 2026
One-click install
npx skills add https://github.com/valorisa/Claude-Skills --skill tdd-hybrid
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-hybrid
Source: https://github.com/valorisa/Claude-Skills/tree/main/skills/tdd-hybrid
Command: npx skills add https://github.com/valorisa/Claude-Skills --skill tdd-hybrid

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common issues of inconsistent test-driven development adoption, skipped test verification, and inefficient workflows when implementing features or fixing bugs, ensuring all production code is backed by verified failing tests.

Core Features & Use Cases

  • Adaptive Triage: Classifies work as LIGHT (simple changes under 20 lines) or FULL (complex features or architectural changes) to apply the appropriate level of rigor without unnecessary overhead.
  • Strict Guardrails: Enforces the Iron Law (no production code without a failing test first) with mandatory RED/GREEN verification steps and anti-rationalization rules to prevent common TDD pitfalls.
  • Structured Workflows: Provides step-by-step processes for both lightweight bug fixes and full feature development, including vertical slicing to avoid inefficient horizontal test writing and domain awareness for complex work.
  • Use Case: For example, when adding a new payment processing feature, the skill guides you to plan required behaviors, write a single end-to-end tracer bullet test first, then incrementally add implementation and tests for each behavior to ensure full coverage.

Quick Start

Use the tdd-hybrid skill to implement the new user profile editing feature following test-first principles with mandatory verification steps.

Frequently Asked Questions about tdd-hybrid

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

FAQPage Schema
How do I enforce test-driven development workflows and stop skipping test verification?

To enforce test-driven development workflows and eliminate skipped test verification, apply mandatory RED/GREEN verification steps with anti-rationalization guardrails. This ensures no production code is written without a corresponding failing test, maintaining strict TDD compliance during feature implementation and bug fixing.

What is the best way to handle test-driven development for both simple bug fixes and complex features?

The best way to handle test-driven development for varying complexity is adaptive triage. It routes simple changes under 20 lines to lightweight TDD loops and directs complex architectural work to full planning workflows with domain awareness, applying the appropriate rigor without unnecessary overhead.

How do I implement a new feature using test-first principles without horizontal test writing?

Implement a new feature using test-first principles by applying vertical slicing. Start by writing a single end-to-end tracer bullet test, then incrementally add implementation and tests for each required behavior to ensure full coverage and avoid inefficient horizontal test writing.

Why does test-driven development adoption often become inconsistent during bug fixing?

Test-driven development adoption becomes inconsistent during bug fixing when workflows lack structured triage and strict guardrails. Without enforced Iron Law rules and mandatory verification, developers often rationalize skipping tests for simple changes, leading to unverified production code.

Do I need to write a full test plan for a small 15-line code change?

You do not need to write a full test plan for a small 15-line code change. Adaptive triage classifies work under 20 lines as LIGHT, routing simple changes to lightweight TDD loops to apply the appropriate level of test verification without unnecessary overhead.