writing-plans

Create file-by-file implementation plans with test-first steps from specs.

1|Updated Apr 14, 2026
One-click install
npx skills add https://github.com/51hhh/BU03 --skill writing-plans-51hhh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/51hhh/BU03/tree/main/.github/skills/writing-plans
Command: npx skills add https://github.com/51hhh/BU03 --skill writing-plans-51hhh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns specs and requirements into clear, actionable implementation plans so engineers can start work with zero context and minimal ambiguity.

Core Features & Use Cases

  • Breaks a feature into small, testable tasks with exact files to create or modify.
  • Defines test-first steps, expected failures, implementation checkpoints, and commit guidance.
  • Helps with multi-step product changes, refactors, and cross-file work that benefits from careful planning before coding.

Quick Start

Ask the writing-plans skill to create a detailed implementation plan for your spec and save it in the default plan location.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn feature specs into actionable implementation plans?

Implementation planning transforms feature specs into actionable plans by performing explicit file-by-file task decomposition, defining test-first steps, and outlining clear execution handoff guidance for engineers.

How do I break down a multi-step software task into testable codebase changes?

Multi-step software task decomposition splits cross-file work into small, testable tasks with exact files to create or modify, defining expected test failures and implementation checkpoints before coding begins.

What is the best way to plan a test-first strategy for a cross-file refactor?

A test-first strategy for cross-file refactors requires defining expected test failures, setting implementation checkpoints, and generating commit guidance to ensure careful planning before coding starts.

Does implementation planning work for existing codebases requiring documentation and review checkpoints?

Implementation planning applies to existing codebases needing feature work that spans files, tests, documentation, and review checkpoints, ensuring zero context startup with minimal ambiguity.

When should I not use a detailed implementation plan for my software project?

Detailed implementation plans should be avoided for single-file changes or simple tasks that do not benefit from careful planning, cross-file work, or explicit test-first task decomposition.