plan-feature

Generate a detailed implementation plan with TDD-aligned test cases for a proposed software feature.

1|Updated Jan 13, 2023
One-click install
npx skills add https://github.com/theodrosyimer/.dotfiles --skill plan-feature-theodrosyimer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan-feature
Source: https://github.com/theodrosyimer/.dotfiles/tree/main/claude/skills/dev__plan-feature
Command: npx skills add https://github.com/theodrosyimer/.dotfiles --skill plan-feature-theodrosyimer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires zod, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Planning a software feature manually often leads to missed edge cases, unclear test coverage, and inefficient implementation order.

Core Features & Use Cases

  • Feature Understanding: Clarifies acceptance criteria and required behavior.
  • Codebase Exploration: Identifies impacted modules using read, grep, and glob tools.
  • Test Strategy Design: Generates a TPP‑ordered list of unit tests with transformation annotations.
  • Implementation Roadmap: Provides ordered file changes and test case locations. Example: Planning an email‑verification feature before writing any code.

Quick Start

Plan the feature “email verification after user signup” with the plan-feature skill.

Frequently Asked Questions about plan-feature

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

FAQPage Schema
How do I create a TDD implementation plan for a new software feature?

To create a TDD implementation plan, you define acceptance criteria, explore the codebase to find impacted modules, and generate a TPP-ordered list of unit tests with transformation steps before writing any code.

What is the best way to plan test cases and code changes before implementing a feature?

The best way to plan test cases is to design a TPP-ordered test strategy that outlines specific test file locations, transformation annotations, and implementation changes without modifying your source files.

How does codebase exploration help identify impacted modules for feature planning?

Codebase exploration for feature planning uses read, grep, and glob tools to scan your repository, identifying the exact modules and files that will be impacted by the proposed software feature.

Can I generate a test strategy and implementation roadmap without modifying my source files?

Yes, you can generate a complete test strategy and implementation roadmap as a structured plan that outlines all test file locations and transformation steps, ensuring your source files remain completely unmodified.

Do I need a specific framework to design a TPP-ordered test strategy for my codebase?

You do not need a specific testing framework, as the plan applies to any codebase where developers need to understand requirements and design TDD-aligned tests, requiring only the zod dependency for validation.

Why does manual feature planning lead to missed edge cases and inefficient implementation?

Manual feature planning leads to missed edge cases because it lacks a structured transformation step ordering and automated codebase exploration, resulting in unclear test coverage and inefficient implementation sequences.