writing-plans

Generate Markdown implementation plans with tasks, files, tests, and documentation.

5|Updated Apr 18, 2026
One-click install
npx skills add https://github.com/russosalv/NONoise --skill writing-plans-russosalv
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/russosalv/NONoise/tree/main/packages/skills/vendor/superpowers/skills/writing-plans
Command: npx skills add https://github.com/russosalv/NONoise --skill writing-plans-russosalv

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps engineering teams convert ambiguous specs into clear, executable implementation plans before writing code.

Core Features & Use Cases

  • Plan decomposition: map out tasks, files, interfaces, and dependencies.
  • Bite-sized task granularity: define actionable steps with checkpoints.
  • Template-driven planning: follow a consistent structure for scoping, risks, and acceptance criteria.
  • Use Case: given a feature spec, generate a complete plan detailing tasks, touched files, tests, and deliverables.

Quick Start

Provide a feature spec and request 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 convert a feature spec into an executable implementation plan?

To convert a feature spec into an implementation plan, provide the spec to generate a structured Markdown document. The output maps out tasks, touched files, interfaces, tests, and deliverables for engineering execution.

What is the best way to decompose ambiguous software requirements into actionable tasks?

Decomposing ambiguous software requirements involves mapping out tasks, files, interfaces, and dependencies. This process yields bite-sized task granularity with actionable steps and checkpoints to guide development teams.

How do I generate an implementation plan for refactoring or new module design?

Generating an implementation plan for refactoring or new module design requires applying the feature specification to a template-driven structure. It produces a Markdown plan covering scoping, risks, acceptance criteria, and save-path conventions.

Does the generated implementation plan include testing and documentation requirements?

Yes, the generated implementation plan includes testing and documentation requirements. It yields a comprehensive plan detailing tasks, touched files, tests, and deliverables suitable for version control execution.

How should I structure implementation plans for version control and team execution?

To structure implementation plans for version control, use a consistent Markdown template with a header, a task list with steps, and save-path conventions like docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md.

Why do I need a template-driven plan before writing code for feature development?

You need a template-driven plan before writing code to convert ambiguous specs into clear, executable steps. It establishes consistent scoping, risks, and acceptance criteria, preventing oversight during feature development.