tdd-planning_skill

Overview

This skill creates implementation plans that enforce a strict Test-Driven Development workflow. Every implementation step is specified as a RED → GREEN → COMMIT/ROLLBACK cycle, including exact test code, expected failures, minimal implementation notes, and commit or rollback commands. It is written with TypeScript projects in mind and suitable for agent-driven workflows.

How this skill works

The skill inspects the codebase and test infrastructure, identifies smallest testable units, and sequences progressive tests from happy paths to edge cases. For each feature it produces a cycle-by-cycle plan: the failing test to write, the expected failure message, the minimal change to make it pass, and the exact commit or rollback commands. It also asks for user preferences up front (commit granularity, rollback strategy, file-review usage) and adapts interaction by autonomy mode (Autopilot, Critical, Verbose).

When to use it

• When you need a disciplined TDD implementation plan for a new feature or bug fix
• For test-critical or safety-critical features requiring verifiable incremental progress
• When integrating agents that must follow reproducible RED→GREEN→COMMIT cycles
• When you want explicit test code and failure messages drafted before implementation
• When coordinating work across multiple contributors using conventional commits

Best practices

• Establish commit granularity and rollback strategy at the start and store them for the workflow
• Always write the failing test first; never describe implementation without the test that drives it
• Keep each TDD cycle small enough to finish in one sitting; break large behaviors into smaller cycles
• Provide exact test code and expected failure output for every RED phase
• Use minimal code in GREEN; avoid speculative changes unrelated to passing the current test
• Use file-review integration (if available) for inline plan feedback before finalizing

Example use cases

• Plan a new API endpoint: start with a unit test for input validation, progress to success responses, then error handling, with commits after each green cycle
• Add a critical bug fix using tests that reproduce the bug, then minimal code to fix and commit safe rollbacks
• Introduce a refactor by writing tests that assert current behavior, refactor in small cycles ensuring tests remain green
• Onboard an agent to implement features: provide stepwise test-first instructions and explicit git commands for each cycle
• Create a safety-critical feature where each step must be reviewed and auditable via commits