writing-plans

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

Updated Mar 19, 2026
One-click install
npx skills add https://github.com/Sungmaster/Sung --skill writing-plans-sungmaster
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Sungmaster/Sung/tree/main/.claude/plugins/superpowers/skills/writing-plans
Command: npx skills add https://github.com/Sungmaster/Sung --skill writing-plans-sungmaster

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of disorganized or overly vague development tasks by enforcing a structured, test-driven, and bite-sized planning process before any code is written.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into granular, 2-5 minute actionable steps.
  • TDD Enforcement: Mandates the creation of failing tests before implementation to ensure code quality and reliability.
  • Use Case: When starting a new feature, use this skill to generate a comprehensive plan that maps out file changes, test cases, and commit points, ensuring the engineer has a clear roadmap to follow.

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 create a TDD implementation plan for complex software features?

To create a TDD implementation plan, you decompose complex features into granular, file-level steps with clear commit points. This enforces writing failing tests before implementation, ensuring engineers execute tasks reliably following TDD, YAGNI, and DRY principles.

What is the best way to break down a large development task for test-driven development?

The best way to break down a large development task is transforming it into bite-sized, 2-5 minute actionable steps. This task decomposition maps out specific file changes, test cases, and commit points, providing a clear roadmap before any code is written.

How do I ensure my development workflow follows YAGNI and DRY principles?

To ensure your development workflow follows YAGNI and DRY principles, generate a structured, test-driven implementation plan before coding. This enforces strict task decomposition and mandates failing tests first, preventing disorganized or vague feature development.

Can I use structured planning to help zero-context engineers execute complex tasks?

Yes, structured planning helps zero-context engineers execute complex tasks reliably. By providing step-by-step execution instructions with file-level decomposition and clear test cases, engineers can follow the roadmap without needing prior project context.

When do I need a structured implementation plan for software engineering?

You need a structured implementation plan when starting complex feature development that requires clear file-level decomposition. It is essential when you must enforce TDD, YAGNI, and DRY principles to prevent disorganized or overly vague development tasks.