tdd-plan

Plan fine-grained TDD cycles pairing each test with minimal implementations.

1|2|Updated Jul 5, 2024
One-click install
npx skills add https://github.com/uuta/dotfiles --skill tdd-plan-uuta
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-plan
Source: https://github.com/uuta/dotfiles/tree/main/skills/tdd-plan
Command: npx skills add https://github.com/uuta/dotfiles --skill tdd-plan-uuta

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps software teams plan and execute fine-grained TDD cycles by mapping each test to an immediate implementation, reducing feedback latency and promoting small, verifiable changes.

Core Features & Use Cases

  • Fine-Grained Cycles: One test per cycle paired with the minimal implementation to pass it.
  • Clear Labelling: Consistent file naming for tests and implementations to maintain traceability.
  • Use Case: A new feature is developed by writing a failing test, implementing the smallest code change, and repeating until all tests pass.

Quick Start

Create a Plan: [Feature Name], then follow the detailed steps to write a RED test, implement the minimal code to pass, and iterate.

Frequently Asked Questions about tdd-plan

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

FAQPage Schema
How do I plan and execute fine-grained TDD cycles for unit testing?

Fine-grained TDD cycles map each test to an immediate minimal implementation, reducing feedback latency. This enforces a concrete workflow with a clear RED→GREEN cycle, file naming conventions, and documentation-driven planning to ensure traceability for unit development.

What is the red-green-refactor workflow for iterative feature development?

The red-green-refactor workflow involves writing a failing RED test, implementing the minimal code to pass it in the GREEN phase, and refactoring. This iterative cycle expands test coverage with small, verifiable steps until all feature tests pass.

How do I maintain traceability between unit tests and implementations during TDD?

Maintain traceability in TDD by applying consistent file naming conventions for tests and implementations. This documentation-driven planning approach ensures each test is explicitly mapped to its corresponding code throughout the development cycle.

Does this TDD workflow approach work for feature development at scale?

This TDD workflow suits unit and feature development where developers iteratively expand coverage. It handles scale by enforcing small, verifiable red-green refactors with explicit file naming, ensuring traceability across multiple fine-grained cycles.

When should I not use fine-grained TDD cycles for software development?

Avoid fine-grained TDD cycles when immediate iterative feedback or traceable unit coverage is unnecessary. If a feature requires broad architectural changes rather than small, verifiable steps, this strict RED→GREEN workflow may introduce unnecessary latency.