plan-to-tdd

Convert documented feature plans into contracts, test scaffolds, and phased execution guidance.

27|9|Updated Jan 4, 2026
One-click install
npx skills add https://github.com/georgekhananaev/claude-skills-vault --skill plan-to-tdd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan-to-tdd
Source: https://github.com/georgekhananaev/claude-skills-vault/tree/main/.claude/skills/plan-to-tdd
Command: npx skills add https://github.com/georgekhananaev/claude-skills-vault --skill plan-to-tdd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Plan-to-TDD converts documented feature plans into test-driven implementation artifacts by deriving contracts, test structures, and phased execution guidance.

Core Features & Use Cases

  • Contract-driven scaffolding: generate interfaces and test skeletons from plans.
  • Outside-In workflow enforcement: guide from system design to unit/integration tests and E2E validation.
  • Plan-to-test generation: convert docs/plan content into structured unit, integration, and E2E test distributions.
  • Use Case: When you have a plan in docs/plan, you can automatically create a test pyramid scaffold and contract interfaces to drive development.

Quick Start

Use plan-to-tdd to transform a feature plan into test-driven implementation by loading a plan from docs/plan and generating unit/integration/E2E scaffolds.

Frequently Asked Questions about plan-to-tdd

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

FAQPage Schema
How do I convert feature plans into test-driven code scaffolds?

To convert feature plans into test-driven code, you can use an Outside-In workflow to derive contracts, generate interface definitions, and create unit, integration, and E2E test scaffolds directly from documented user stories.

What is the Outside-In testing workflow for translating system designs?

The Outside-In testing workflow translates system designs by starting from E2E validation scopes, moving inward to integration tests, and ending with unit tests, enforcing a contract-driven development path from design to verification.

How do I generate unit, integration, and E2E test structures from a plan directory?

You can generate unit, integration, and E2E test structures by loading a feature plan from a docs/plan directory, which allows you to automatically create a test pyramid scaffold and define the necessary contract interfaces.

Can I use contract-driven scaffolding to define interfaces for user stories?

Yes, contract-driven scaffolding defines interfaces and generates test skeletons from user stories, ensuring your implementation artifacts match the documented feature plan requirements across all test scopes.

Do I need a specific plan directory structure to generate test scaffolds?

Yes, you need your feature plans stored in a docs/plan directory, which the system reads to convert documented user stories and system designs into structured test distributions and phased execution guidance.

What is the best way to structure tests when starting from a feature plan?

The best way to structure tests from a feature plan is applying a phased execution approach that distributes tests across unit, integration, and E2E scopes while generating contract interfaces to drive the implementation.