bp-tdd-review

Rewrite plan files into a Red/Green/Refactor TDD sequence.

4|Updated Mar 24, 2026
One-click install
npx skills add https://github.com/skaisser/blueprint --skill bp-tdd-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bp-tdd-review
Source: https://github.com/skaisser/blueprint/tree/main/skills/bp-tdd-review
Command: npx skills add https://github.com/skaisser/blueprint --skill bp-tdd-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Automates and enforces a disciplined planning workflow by converting an existing plan into a Red/Green/Refactor cycle, ensuring tests are written before implementations and the plan is consistently structured.

Core Features & Use Cases

  • Structured TDD workflow: transforms plan-review into Red (failing tests), Green (implementation), and Refactor (coverage) phases.
  • Phase injection and mapping: automatically inserts Phase 0 tests and maps each RED task to a corresponding GREEN implementation task.
  • Non-destructive transformations: restructures the plan file without executing or writing code, preserving user data and intent.
  • End-to-end plan quality: supports audit trails, dependency tracking, and coverage verification across the entire plan lifecycle.

Quick Start

Execute /bp-tdd-review on the current plan to generate a RED Phase 0 test suite, GREEN implementations, and a final coverage phase.

Frequently Asked Questions about bp-tdd-review

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

FAQPage Schema
How do I automate my TDD plan-review workflow with a Red/Green/Refactor sequence?

Automating a TDD plan-review workflow involves rewriting existing plan files into a strict Red/Green/Refactor sequence, enforcing test-first design. This process automatically injects Phase 0 failing tests and maps each RED task to a corresponding GREEN implementation task.

What is a non-destructive TDD plan transformation and how does it work?

A non-destructive TDD plan transformation restructures your software planning documents into Red, Green, and Refactor phases without executing or writing any actual code. It preserves your original user data and intent while enforcing strict phase mapping and coverage verification.

How to map failing tests to implementation tasks in a software plan?

To map failing tests to implementation tasks, you rewrite the plan to inject a Phase 0 test suite representing the RED phase. The workflow then automatically maps each RED failing test task to its corresponding GREEN implementation task for structured coverage.

Does TDD plan-review support dependency tracking and audit trails?

Yes, TDD plan-review supports audit trails and dependency tracking across the entire plan lifecycle. It enforces an auditable transformation workflow that documents dependencies, phase mappings, and error handling without executing code.

Can I use TDD plan restructuring for automation tasks requiring coverage verification?

Yes, you can use TDD plan restructuring for automation tasks where plan validation and coverage verification must be enforced. It transforms plans into a strict Red/Green/Refactor cycle, ensuring tests precede implementations and verifying end-to-end plan quality.

When should I not use automated TDD plan transformation?

You should not use automated TDD plan transformation when you need to execute code or generate actual implementation files, as this workflow is strictly non-destructive. It only restructures and documents the plan file without writing or running any code.