feature-planning-tdd

Generate a TDD plan with acceptance criteria and failing tests before code.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/roaming-rockenfels/ghostfolio --skill feature-planning-tdd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-planning-tdd
Source: https://github.com/roaming-rockenfels/ghostfolio/tree/main/.claude/skills/feature-planning-tdd
Command: npx skills add https://github.com/roaming-rockenfels/ghostfolio --skill feature-planning-tdd

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that new features, bug fixes, or milestone tasks are planned and implemented using a Test-Driven Development (TDD) approach, guaranteeing that code is written only after failing tests are defined and that documentation impacts are assessed upfront.

Core Features & Use Cases

  • TDD Workflow Enforcement: Guides users through the Red-Green-Refactor cycle.
  • Pre-computation of Tests: Generates a list of test cases and acceptance criteria before any code is written.
  • Documentation Impact Analysis: Assesses necessary updates to documentation and diagrams.
  • Use Case: When starting to implement a new API endpoint for user authentication, this Skill would first define the tests for invalid credentials, successful login, and rate limiting, then outline the minimal code to pass these tests, and finally identify which API documentation files need updating.

Quick Start

Use the feature-planning-tdd skill to plan the implementation of the new user profile update feature.

Frequently Asked Questions about feature-planning-tdd

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

FAQPage Schema
How do I plan a feature using test-driven development?

To plan a feature using test-driven development, you define acceptance criteria and generate a list of failing tests before writing any code. This enforces a Red-Green-Refactor workflow to guide implementation.

What is the Red-Green-Refactor cycle in TDD?

The Red-Green-Refactor cycle in TDD involves writing failing tests first, creating minimal implementation steps to pass those tests, and then cleaning up the code. This ensures structured feature planning.

How do I assess documentation impact before implementing a new API endpoint?

You assess documentation impact before implementing an API endpoint by generating a TDD plan that identifies necessary updates to documentation and diagrams alongside test cases and implementation steps.

Can I use TDD planning for bug fixes and milestone tasks?

Yes, you can use TDD planning for bug fixes and milestone tasks. It generates a comprehensive plan with acceptance criteria, failing tests, minimal code steps, and documentation updates before development begins.

How do I write failing tests before writing any implementation code?

You write failing tests before implementation code by pre-computing test cases during the RED phase of the TDD workflow. The Skill generates these tests based on defined acceptance criteria.

What are the limitations of enforcing a TDD workflow for feature planning?

A limitation of enforcing a TDD workflow for feature planning is that it requires defining acceptance criteria and failing tests upfront, which may not suit rapid prototyping or highly exploratory development tasks.