writing-plans

Draft task-oriented implementation plans from a project spec.

Updated Mar 31, 2026
One-click install
npx skills add https://github.com/hetsheth-droid/toolbox-template --skill writing-plans-hetsheth-droid
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/hetsheth-droid/toolbox-template/tree/main/incubating/superpowers-skills/writing-plans
Command: npx skills add https://github.com/hetsheth-droid/toolbox-template --skill writing-plans-hetsheth-droid

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. Frequent commits.

Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.

Core Features & Use Cases

  • Comprehensive task decomposition: breaks down a spec into actionable steps with clear ownership and outputs.
  • Documentation of artifacts: lists all files to create/modify, tests to run, and docs to review.
  • Iterative planning guidance: supports lightweight, test-driven planning with frequent commits and traceable changes.

Quick Start

Provide a project spec, and I will generate a complete, executable implementation plan.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a software specification into actionable implementation tasks?

Implementation plans map a spec to executable steps by detailing task decomposition, file modifications, testing requirements, and documentation. They enforce DRY, YAGNI, and TDD principles while providing bite-sized tasks with frequent commit checkpoints.

What is the best way to write an implementation plan for a developer with no codebase context?

Writing an implementation plan for context-free developers means documenting every artifact: which files to touch, code requirements, test design, and docs to check. This ensures executable, traceable steps aligned with test-driven development principles.

Does this planning approach support test-driven development and frequent commits?

Yes, the planning approach supports test-driven development by defining tests for each task and enforcing frequent commits. It provides iterative planning guidance with traceable changes throughout the software implementation workflow.

Can I use this to generate a plan for any software design project?

You can generate a plan for any software project requiring decomposition into concrete tasks. It works with any project spec to produce comprehensive implementation steps, assuming the developer is skilled but unfamiliar with your toolset.

What principles guide the task decomposition in these software implementation plans?

The task decomposition in these implementation plans is guided by DRY, YAGNI, and TDD principles. This ensures developers avoid duplication, build only what is necessary, and design adequate tests for each executable step.