tdd

Enforce vertical tracer bullet red-green-refactor cycles for behavior-focused integration testing.

4|2|Updated Jun 20, 2026
One-click install
npx skills add https://github.com/saitarrun/devforge-ai --skill tdd-saitarrun
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/saitarrun/devforge-ai/tree/main/skills/tdd
Command: npx skills add https://github.com/saitarrun/devforge-ai --skill tdd-saitarrun

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the common failures of ad-hoc test-driven development: writing brittle tests that break during code refactors, building features that don't match user requirements, and wasting effort on horizontal test writing that validates imagined behavior instead of actual user-facing functionality.

Core Features & Use Cases

  • Vertical Tracer Bullet Workflow: Enforces one-test-one-implementation cycles instead of bulk test writing, ensuring each test validates real, observed behavior.
  • Behavior-Focused Test Guidance: Teaches writing integration-style tests through public interfaces that survive internal refactors, avoiding implementation-coupled test failures.
  • Anti-Pattern Protection: Explicitly warns against common TDD mistakes like horizontal slicing and speculative feature implementation.
  • Use Case: When building a new user authentication feature, use this Skill to write a single test for valid login first, implement the minimal code to pass it, then iterate on edge cases like invalid passwords one test at a time.

Quick Start

Use the tdd skill to implement the new order tracking feature following the red-green-refactor vertical slice workflow, prioritizing tests for public interface behavior over internal implementation details.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I write behavior-focused integration tests that survive code refactoring?

Behavior-focused integration testing validates software through public interfaces rather than internal implementation details, ensuring tests survive refactoring. This approach confirms actual user-facing functionality instead of coupling tests to specific code structures that change during updates.

What is the vertical tracer bullet workflow in test-driven development?

Vertical tracer bullet workflow enforces one-test-one-implementation cycles during test-driven development. Instead of bulk test writing, you write a single test for observed behavior, implement minimal code to pass it, then iterate to the next edge case.

Why do my tests break when I refactor code?

Tests break during refactoring because of implementation-coupled test design, where tests validate internal code structure instead of public interface behavior. Writing integration-style tests through public interfaces prevents these failures by avoiding horizontal test writing and speculative feature implementation.

How do I apply red-green-refactor cycles for new feature development?

Apply red-green-refactor cycles by writing a failing integration test for a specific user-facing behavior, implementing the minimal code required to pass it, and then refactoring the codebase. This vertical slice approach ensures each test validates real, observed functionality before moving forward.

When should I avoid horizontal test writing in test-driven development?

Avoid horizontal test writing when building new features or fixing bugs, because it validates imagined behavior instead of actual user-facing functionality. Horizontal slicing leads to brittle, implementation-coupled tests that fail to verify real software requirements and break during refactoring.