writing-plans

Create step-by-step implementation plans from specs before coding.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Drafting comprehensive, step-by-step implementation plans from a spec or requirements before touching code, preventing ambiguity and misalignment.

Core Features & Use Cases

  • Structured planning: break down specs into concrete tasks, files to touch, tests, docs, and commit steps.
  • Standards and best practices: DRY, YAGNI, TDD, and frequent commits to keep history clean.
  • Scope guidance: when specs cover multiple subsystems, decompose into separate, executable plan documents and save them with standardized filenames.
  • Collaboration: produce plans that can be reviewed and used by engineers, testers, and docs teams.

Quick Start

Generate a complete implementation plan from the provided spec and save it to docs/superpowers/plans/YYYY-MM-DD-writing-plans.md

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create a step-by-step implementation plan from a software spec?

To create an implementation plan from a spec, decompose requirements into concrete tasks with clear boundaries. Document specific files to touch, tests to write, documentation updates, and commit steps, then save the plan to a standardized markdown file path.

What is the best way to plan a multi-subsystem software project before coding?

Planning a multi-subsystem software project requires decomposing complex specifications into separate, executable plan documents. This structured approach prevents ambiguity by defining clear boundaries, specific files to modify, and test requirements for each subsystem before coding begins.

How do I break down project requirements into executable tasks using TDD?

Break down project requirements into executable tasks by applying Test-Driven Development principles. Structure each plan step to include writing tests first, touching specific files, updating documentation, and making frequent commits to keep the project history clean.

Can I use structured task planning for cross-functional engineering and documentation teams?

Structured task planning is designed for cross-functional collaboration. It produces comprehensive, step-by-step plans from specs that can be reviewed and executed by engineers, testers, and documentation teams to ensure alignment across all project members.

When should I not use a single implementation plan for a complex software project?

You should not use a single implementation plan when a spec covers multiple subsystems. Instead, decompose the complex project into separate, executable plan documents to maintain clear boundaries and prevent scope creep during development.

What standards should an implementation plan follow to keep git history clean?

An implementation plan should follow DRY and YAGNI standards to keep git history clean. Structure the plan to enforce frequent, logical commits, detailing which files to touch and tests to write at each step of the task decomposition process.