writing-plans

Create detailed implementation plans with file impact mapping and task decomposition.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The writing-plans skill keeps engineers from diving straight into implementation by forcing them to document the required files, tests, and procedures for every multi-step spec as a shared, actionable plan before writing any code.

Core Features & Use Cases

  • File impact mapping and scope checks: Identify all files to create or modify, reason about decomposition, and flag specs that should split into independent subsystem plans.
  • Bite-sized task breakdown: Write step-by-step tasks with explicit file edits, tests, commands, and commit instructions while emphasizing TDD, frequent commits, and explicit tool context expectations.
  • Structured plan workflow: Start plans with the required header, save them under the default docs/superpowers path (or user preference), run the three-part self-review checklist, and offer execution choices with the proper sub-skill guidance.

Quick Start

Use the writing-plans skill to draft a detailed implementation plan covering files, tests, tasks, and commits before coding begins.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create an implementation plan before writing code for a multi-step engineering task?▼

To create an implementation plan, you map file impacts, decompose tasks into step-by-step instructions with code samples, define testing strategies, and establish a commit workflow before coding begins.

What is task decomposition and file impact mapping in software engineering planning?▼

Task decomposition and file impact mapping involve identifying all files to create or modify for a spec, breaking down multi-step engineering work into bite-sized tasks, and flagging specs that need splitting into independent subsystems.

How do I structure a detailed engineering plan with a self-review checklist?▼

Structure an engineering plan by starting with a required header, writing per-task steps with explicit file edits and command expectations, saving it under a docs path, and running a three-part self-review checklist to verify completeness.

When should I split a large spec into independent subsystem implementation plans?▼

You should split a large spec into independent subsystem implementation plans during file impact mapping when scope checks reveal the engineering task is too broad to be handled by a single multi-step plan.

Does writing an implementation plan include testing strategy and commit workflow guidance?▼

Writing an implementation plan includes testing strategy and commit workflow guidance by emphasizing Test-Driven Development (TDD), specifying frequent commits, and providing explicit tool context expectations for each task.

What is the best way to document required files and procedures for a new engineering spec?▼

The best way to document required files and procedures is to generate a structured, actionable plan that details file edits, tests, commands, and commit instructions, preventing engineers from diving straight into coding.