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.