writing-plans

Create detailed implementation plans with task decomposition and dependency ordering.

4|2|Updated Apr 1, 2026
One-click install
npx skills add https://github.com/anderson-0/mighty-powers --skill writing-plans-anderson-0
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/anderson-0/mighty-powers/tree/main/skills/writing-plans
Command: npx skills add https://github.com/anderson-0/mighty-powers --skill writing-plans-anderson-0

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the problem of unclear or incomplete implementation planning by turning specifications and requirements into detailed, actionable engineering plans before code changes begin.

Core Features & Use Cases

  • Structured Implementation Planning: Creates architecture notes, dependency-aware task breakdowns, wave-based execution plans, and verification steps for software projects.
  • TDD and Quality Guidance: Defines testing approaches, file structures, checkpoints, and implementation details to help engineers execute consistently.
  • Use Case: A team receives a multi-file feature request and uses this Skill to produce a complete implementation roadmap with tasks, dependencies, tests, and review checkpoints.

Quick Start

Use the writing-plans skill to create an implementation plan for this feature specification before modifying any code.

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 for a multi-file software feature?

To create an implementation plan, decompose the feature specification into explicit tasks, order dependencies, map file structures, and define verification checkpoints before modifying any code.

What is task decomposition in software development planning?

Task decomposition is the process of breaking down a software specification into explicit, dependency-ordered engineering tasks and wave-based execution plans to ensure reliable implementation.

How does architecture planning integrate with TDD workflows?

Architecture planning integrates with TDD by defining testing approaches, file structures, and review checkpoints upfront, creating a roadmap that guides consistent test-driven implementation.

Can I use this approach for coordinated multi-step engineering work?

Yes, this approach handles coordinated engineering workflows by producing a complete implementation roadmap with dependency-aware task breakdowns and verification steps for team execution.

What's the best way to structure verification checkpoints before coding starts?

The best way to structure verification checkpoints is to map them directly to task dependencies and testing decisions within the implementation plan, ensuring consistent execution and review.

When do I need a wave-based execution plan for feature development?

You need a wave-based execution plan when a feature requires multi-step engineering work with complex dependency ordering, ensuring tasks are executed reliably in the correct sequence.