evanflow-tdd

Guides vertical-slice TDD workflows through RED-GREEN-REFACTOR cycles using public interfaces.

417|18|Updated Apr 27, 2026
One-click install
npx skills add https://github.com/evanklem/evanflow --skill evanflow-tdd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: evanflow-tdd
Source: https://github.com/evanklem/evanflow/tree/main/skills/evanflow-tdd
Command: npx skills add https://github.com/evanklem/evanflow --skill evanflow-tdd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Vertical-slice TDD enforces testing against public behavior and prevents brittle, implementation-driven code by guiding teams through one-test-at-a-time cycles.

Core Features & Use Cases

  • Vertical-slice testing: write a single test that exercises a feature end-to-end via its public contract.
  • Per-cycle discipline: RED-GREEN-REFACTOR workflow with a safety net of refactoring after each green.
  • Safe incremental delivery: ensures changes remain aligned with user-visible behavior across backend and frontend.

Quick Start

Write one behavior test for a public contract and implement only enough code to pass, then refactor.

Frequently Asked Questions about evanflow-tdd

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

FAQPage Schema
What is vertical-slice TDD and how does it guide feature delivery?

Vertical-slice TDD is a testing methodology that enforces building features through a strict RED-GREEN-REFACTOR cycle, emphasizing behavior via public interfaces rather than internal implementation details for reliable delivery.

How do I write tests using a public interface instead of internal implementation?

To write tests using a public interface, you write a single behavior test that exercises a feature end-to-end via its public contract, implementing only enough code to pass before refactoring safely.

Can I use vertical-slice TDD for bug fixes and frontend logic changes?

Yes, vertical-slice TDD applies to any production code change, including bug fixes and behavior changes, ensuring changes remain aligned with user-visible behavior across both backend services and frontend logic.

What's the best way to refactor code safely during a TDD cycle?

The best way to refactor safely during TDD is to follow strict per-cycle discipline, performing incremental refactors only after achieving a green test state to maintain a reliable safety net.

Why does testing implementation details create brittle code?

Testing implementation details creates brittle code because it couples tests to internal structures rather than user-visible behavior, whereas vertical-slice TDD focuses on public contracts to prevent implementation-driven breakage.

Do I need specific testing frameworks to start vertical-slice TDD?

No specific testing frameworks are required to start vertical-slice TDD. The methodology focuses on the per-cycle RED-GREEN-REFACTOR workflow and testing via public interfaces, making it applicable to any production code environment.