writing-plans

Generate structured, test-driven implementation plans with file-level decomposition.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of vague or poorly structured development tasks by forcing a rigorous, test-driven, and bite-sized implementation plan before any code is written.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into granular, 2-5 minute actionable steps.
  • TDD Enforcement: Mandates a red/green testing cycle for every component.
  • Use Case: When starting a new feature, use this skill to generate a comprehensive plan that ensures the agent follows DRY and YAGNI principles while maintaining clear file boundaries.

Quick Start

Use the writing-plans skill to create an implementation plan for the new user authentication module based on the provided requirements.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a complex software feature into actionable steps for an agentic worker?

Test-driven development plans enforce a red/green testing cycle for every component by mandating tests before writing code. This ensures adherence to TDD, YAGNI, and DRY principles while maintaining actionable task granularity throughout the development workflow.

What is the best way to plan a new feature module while enforcing DRY and YAGNI principles?

The best way to plan a new feature module while enforcing DRY and YAGNI principles is to generate a structured, test-driven implementation plan before coding. This prevents vague tasks by ensuring clear file boundaries and strict architectural compliance.

Can I use this approach to create an implementation plan for a user authentication module?

Task decomposition is necessary for complex feature development when you need to prevent vague or poorly structured development tasks. It forces a rigorous breakdown into bite-sized steps, ensuring agentic workers can execute instructions without ambiguity.

Does TDD planning work with existing codebases that do not follow strict test-first workflows?

TDD planning applies specifically to complex feature development requiring clear file-level decomposition. If an existing codebase lacks test-first workflows, this planning method still mandates a red/green testing cycle for every newly developed component to ensure strict compliance.