writing-plans

Generate implementation plans from specs with file mappings and test-driven steps.

Updated May 28, 2026
One-click install
npx skills add https://github.com/haryelramalho/skills --skill writing-plans-haryelramalho
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/haryelramalho/skills/tree/main/skills/community/writing-plans
Command: npx skills add https://github.com/haryelramalho/skills --skill writing-plans-haryelramalho

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns a spec or requirements document into a clear implementation plan before any code changes begin, reducing guesswork and rework.

Core Features & Use Cases

  • Breaks large requests into small, testable tasks with clear sequencing.
  • Maps each task to exact files, tests, docs, and validation steps.
  • Helps engineers who are new to the codebase move from requirements to execution with confidence.
  • Useful for features, refactors, bug fixes, and multi-file changes that need careful coordination.

Quick Start

Use the writing-plans skill to turn the provided spec into a detailed implementation plan and save it to 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 software specs into execution-ready implementation plans?

Implementation plans are generated from specs by decomposing multi-step software tasks into bite-sized, test-driven steps. This process maps exact files, tests, and validation commands before any code changes begin, ensuring clear sequencing and execution order.

What is the best way to decompose a multi-file refactor into testable tasks?

Task decomposition for multi-file refactors breaks large requests into small, testable tasks with clear sequencing. Each task maps to exact files, tests, docs, and validation steps, helping engineers move from requirements to execution with confidence.

Can I use this approach for requirements analysis on bug fixes?

Requirements analysis for bug fixes and cross-file feature work is supported by generating detailed implementation plans. It applies to multi-step software tasks that require careful coordination, reducing guesswork and rework.

How do I map exact files and test driven development steps before coding?

Test driven development steps are mapped by generating placeholder-free instructions with exact commands and explicit file mapping. This ensures an engineer can follow the execution-ready plan without prior context.

When do I need to generate an implementation plan for a software design task?

An implementation plan is needed for software design tasks involving multi-step execution, refactors, or cross-file feature work. Generating a plan before coding begins reduces guesswork by providing clear decomposition and execution order.

Does this planning method work for engineers new to a codebase?

Engineers new to a codebase benefit from implementation plans that provide clear decomposition and execution order. Placeholder-free instructions with exact file mapping and validation steps allow them to execute multi-step software tasks confidently.