tdd

Enforce vertical slicing and public seam verification in test-driven development workflows.

Updated May 3, 2026
One-click install
npx skills add https://github.com/druejaramillo/skills --skill tdd-druejaramillo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/druejaramillo/skills/tree/main/project/tdd
Command: npx skills add https://github.com/druejaramillo/skills --skill tdd-druejaramillo

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill addresses the common pitfalls of test-driven development, such as testing implementation details instead of behavior, and prevents the anti-pattern of horizontal slicing where tests are written in bulk without actual implementation feedback.

Core Features & Use Cases

  • Vertical Slicing: Guides you through the tracer bullet approach, ensuring each test corresponds to a single, minimal implementation step.
  • Behavior-Driven Design: Focuses on testing public seams and observable behavior, ensuring your test suite remains resilient during refactoring.
  • Refactoring Guardrails: Provides clear criteria for when to refactor and how to maintain behavior-preserving changes without adding scope.

Quick Start

Invoke the tdd skill to help me implement the new user authentication feature using a vertical red-green-refactor cycle.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I stop my test-driven development tests from breaking during refactoring?

Test-driven development tests break during refactoring when they validate implementation details instead of behavior. Focusing on observable public seams ensures your test suite remains resilient to structural changes.

What is the best way to implement a new feature using a red-green-refactor cycle?

The best way to implement features using a red-green-refactor cycle is through vertical slicing. This tracer bullet approach ensures each test corresponds to a single, minimal implementation step for immediate feedback.

Why does writing all my integration tests upfront lead to maintainability issues?

Writing integration tests upfront creates a horizontal slicing anti-pattern where bulk tests lack actual implementation feedback. This detaches testing from software design, reducing architectural maintainability.

When should I refactor code in a TDD workflow without adding new scope?

You should refactor code in a TDD workflow only after achieving a passing test state. Strict criteria mandate behavior-preserving changes to existing implementation without expanding feature scope.

Does strict TDD require minimal implementation steps for every integration test?

Yes, strict test-driven development requires minimal implementation steps for every integration test. This vertical slicing enforces high test coverage and maintainable architecture through immediate feedback loops.

Can I use tracer bullets for both feature development and bug fixing tasks?

Yes, you can use tracer bullets for both feature development and bug fixing tasks. This vertical slicing approach enforces behavior-focused testing and high coverage across all implementation workflows.