Write Plan Skill

Translate design documents into incremental implementation plans with tasks, tests, and acceptance criteria.

2|1|Updated Dec 16, 2025
One-click install
npx skills add https://github.com/shsrams/kiro-cli-bootstrap --skill write-plan-skill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Write Plan Skill
Source: https://github.com/shsrams/kiro-cli-bootstrap/tree/main/skills/write-plan
Command: npx skills add https://github.com/shsrams/kiro-cli-bootstrap --skill write-plan-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams transform design documents into actionable, test-driven implementation plans, reducing project risk and miscommunication.

Core Features & Use Cases

  • Supports automatic decomposition of design into incremental, testable steps
  • Enforces YAGNI, DRY, and SOLID principles during planning
  • Provides quick-start guidance and checks for dependency readiness

Quick Start

Convert a detailed design document into a step-by-step, test-driven implementation plan that can be executed incrementally.

Frequently Asked Questions about Write Plan Skill

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

FAQPage Schema
How do I convert a software design document into a step-by-step implementation plan?

To convert a design document into an implementation plan, decompose the design into incremental, testable steps. The plan must include specific tasks, dependencies, tests, and acceptance criteria while adhering to TDD, SOLID, and YAGNI principles.

What is test-driven development planning and how does it apply to software engineering tasks?

Test-driven development planning translates designs into actionable steps where tests define milestones and acceptance criteria. It applies to software engineering tasks by enforcing YAGNI, DRY, and SOLID principles during decomposition to reduce project risk and miscommunication.

Does this approach support enforcing SOLID and DRY principles during task decomposition?

Yes, the planning approach supports enforcing SOLID and DRY principles during decomposition. It automatically translates detailed designs into incremental steps that explicitly adhere to SOLID, DRY, and YAGNI principles, ensuring clean architecture and reducing redundant code.

Can I generate acceptance criteria and dependency checks for agile software projects?

Yes, you can generate acceptance criteria and dependency checks for agile software projects. The planning process checks for dependency readiness and provides quick-start guidance by mapping out concrete tasks, tests, and dependencies directly from the design document.

What is the best way to structure incremental milestones for a new software feature?

The best way to structure incremental milestones is to break down the design into testable, sequential steps. Each milestone includes specific tasks, dependencies, and acceptance criteria, ensuring the implementation plan can be executed incrementally and validated through tests.

Why does my software implementation plan lack clear testable steps and acceptance criteria?

Your software implementation plan lacks clear testable steps because it was not decomposed using test-driven design principles. Translating the design document into an actionable plan ensures each step has defined tests, dependencies, and acceptance criteria to prevent miscommunication.