writing-plans

Generate implementation plans with file changes, testing, and milestones from vague specs.

146|35|Updated Mar 20, 2023
One-click install
npx skills add https://github.com/mwangli/stock-trading --skill writing-plans-mwangli
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/mwangli/stock-trading/tree/main/.trae/skills/writing-plans
Command: npx skills add https://github.com/mwangli/stock-trading --skill writing-plans-mwangli

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams convert vague requirements and multi-step tasks into concrete, executable plans that guide engineers through design, implementation, testing, and delivery.

Core Features & Use Cases

  • Comprehensive task decomposition: defines files to touch, tests to write, and milestones.
  • Standardized planning templates: ensures consistency with Plan Document Header and step-by-step tasks.
  • Execution handoff: saves plans to docs/superpowers/plans with date and feature name.

Quick Start

Create a feature plan using the plan template and save it to docs/superpowers/plans/YYYY-MM-DD-writing-plans.md.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I convert vague software requirements into a concrete implementation plan?

To convert vague software requirements into an implementation plan, you need a structured planning approach that decomposes complex multi-subsystem features into file changes, testing milestones, and step-by-step tasks. This ensures repeatable and auditable development.

What is the best way to structure technical documentation for multi-subsystem architecture tasks?

The best way to structure technical documentation for architecture tasks is using a standardized plan template with a Plan Document Header, task-level steps, and file mappings to ensure consistent execution and clear milestone tracking.

Can I generate an executable development plan for complex software features without detailed specs?

Yes, you can generate a development plan for complex software features from vague specs by applying comprehensive task decomposition that outlines specific file changes, testing requirements, and delivery milestones.

How to create step-by-step implementation blueprints that map out file changes and tests?

To create implementation blueprints that map out file changes and tests, apply a standardized plan structure defining files to touch, tests to write, and milestones, saving the output to a dated plans directory for execution handoff.

Why does my development team need standardized plan templates for feature implementation?

Your development team needs standardized plan templates for feature implementation to enforce consistent task decomposition, file mapping, and milestone tracking across multi-subsystem projects, enabling repeatable and auditable development.

Does plan-driven implementation work for multi-subsystem software features with multiple milestones?

Plan-driven implementation works effectively for multi-subsystem software features by defining comprehensive task decomposition, outlining specific file changes, and establishing clear testing milestones throughout the delivery lifecycle.