writing-plans

Convert vague specifications into detailed implementation plans with file targets and testing steps.

5|Updated Feb 10, 2026
One-click install
npx skills add https://github.com/jsloat/superpowers-for-copilot --skill writing-plans-jsloat
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/jsloat/superpowers-for-copilot/tree/main/skills/writing-plans
Command: npx skills add https://github.com/jsloat/superpowers-for-copilot --skill writing-plans-jsloat

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams convert vague specs or requirements into comprehensive, executable implementation plans for multi-step tasks.

Core Features & Use Cases

  • Comprehensive task decomposition: breaks a feature into concrete steps with precise file paths, tests to write, and documentation needs.
  • Guided, incremental execution: presents step-by-step actions with checkpoints for testing and frequent commits.
  • Handoff-ready documentation: produces plans suitable for review, collaboration, and onboarding new contributors.

Quick Start

Generate a complete, step-by-step implementation plan based on a provided spec for a feature.

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 vague feature specification into executable implementation steps?

Implementation plans decompose vague specifications into executable steps, detailing exact file targets, required tests, and documentation references. This structured task breakdown guides developers incrementally from initial testing through final deployment using clear checkpoints.

What is the best way to create a test-driven development plan for a complex software refactor?

A test-driven development plan for complex refactors maps out precise file paths and specific tests to write before implementation. It sequences incremental actions with frequent commit checkpoints, ensuring refactoring adheres to TDD and DRY principles throughout the workflow.

How do I generate handoff-ready documentation for multi-step feature development?

Generate handoff-ready documentation by converting feature requirements into step-by-step plans with precise file targets and documentation references. This produces actionable artifacts suitable for team review, collaboration, and onboarding new software engineering contributors.

Does this planning workflow support incremental execution with frequent commits?

Yes, this planning workflow explicitly supports incremental execution by structuring tasks into guided steps with built-in checkpoints. It mandates frequent commits at each testing phase, ensuring stable, verifiable progress throughout the software engineering lifecycle.

Can I use these implementation plans for both new feature development and complex refactors?

Yes, you can use these implementation plans for both new feature development and complex refactors. The planning process applies comprehensively across projects, converting requirements into detailed steps with precise file paths, tests, and documentation needs.

Why do I need to include specific file targets and commit messages in my task breakdown?

Including specific file targets and predefined commit messages in your task breakdown ensures precise execution and clear version control history. This structured planning enforces test-driven development and DRY principles, making incremental progress verifiable and stable.