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.