create-plan

Create implementation plans with behavior specs, tests, and stepwise tasks.

Updated Jan 19, 2026
One-click install
npx skills add https://github.com/KAFKA2306/yt3 --skill create-plan-kafka2306
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: create-plan
Source: https://github.com/KAFKA2306/yt3/tree/main/.claude/skills/create-plan
Command: npx skills add https://github.com/KAFKA2306/yt3 --skill create-plan-kafka2306

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates ambiguity between chosen designs and executable work by converting a selected solution into a detailed, testable implementation plan that prevents rushed shortcuts and long-term technical debt.

Core Features & Use Cases

  • Behavior Specification: Document desired and undesired behavior, success criteria, and boundary conditions for each feature.
  • Test Design: Produce unit and integration test outlines and test cases before implementation.
  • First-Principles & Readiness Checks: Enforce deep context gathering, dependency analysis, and a first-principles checklist to avoid shortcuts and hidden assumptions.
  • Use Case: After /design-solution selects an approach, use this Skill to generate the stepwise development plan, required tests, and acceptance criteria for engineers and PMs.

Quick Start

Use the create-plan skill to generate a detailed implementation plan with behavior specs, edge case handling, and test definitions for the chosen solution.

Frequently Asked Questions about create-plan

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

FAQPage Schema
How do I turn a solution design into an implementation plan for developers?

Implementation plans bridge design and execution by documenting explicit behavior specifications, edge cases, and step-by-step tasks. They prevent rushed shortcuts and technical debt by enforcing first-principles checks and readiness analysis before development begins.

How do I define edge cases and test cases before implementation starts?

Defining edge cases and test cases before coding involves creating explicit behavior specifications, boundary conditions, and test outlines. This approach enforces first-principles readiness checks to prevent shortcuts and long-term technical debt during development.

What is the best way to document behavior specifications for a software feature?

Documenting behavior specifications requires recording desired and undesired behavior, success criteria, and boundary conditions for each feature. This eliminates ambiguity between chosen designs and executable work by providing explicit, testable specifications.

Can I generate step-by-step development tasks from a chosen software architecture?

Generating step-by-step development tasks from software architecture involves applying first-principles checks, dependency analysis, and behavior specification. This produces stepwise execution tasks and acceptance criteria that prevent rushed shortcuts and hidden assumptions.

Why do implementation plans need first-principles checks and readiness analysis?

First-principles checks and readiness analysis are needed in implementation plans to enforce deep context gathering and avoid shortcuts. This prevents long-term technical debt by ensuring dependency analysis and hidden assumptions are addressed before executable work begins.

Does creating an implementation plan require a completed solution design first?

Creating an implementation plan requires a completed solution design because it converts the chosen approach into testable specifications and stepwise execution tasks. Applying it after solution design ensures all behavior specs and tests align with the selected architecture.