writing-plans

Generates detailed implementation plans with bite-sized TDD tasks from feature specifications.

Updated Apr 17, 2026
One-click install
npx skills add https://github.com/Syedyasir001/RVULibPass --skill writing-plans-syedyasir001
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Syedyasir001/RVULibPass/tree/main/.agent/skills/library/writing-plans
Command: npx skills add https://github.com/Syedyasir001/RVULibPass --skill writing-plans-syedyasir001

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often start coding from a spec without a clear roadmap, leading to missed requirements, vague tasks, and inconsistent execution. This Skill converts a spec or requirements document into a complete, step-by-step implementation plan that any engineer can follow without prior codebase context. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD: write failing test, verify failure, implement, verify pass, commit. - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, exact commands, and expected outputs in every step. - Self-Review and Handoff: Includes a spec-coverage and consistency self-review checklist, plus an execution handoff offering subagent-driven or inline execution. - Use Case: After brainstorming a new feature spec, use this Skill to produce a dated plan document in docs/superpowers/plans/ with checkbox-tracked tasks ready for task-by-task implementation. ## Quick Start Use the writing-plans skill to turn my feature spec into a step-by-step implementation plan with TDD tasks and exact file paths.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I write an implementation plan from a feature spec?▼

Start with a plan header stating goal, architecture, and tech stack, then map the file structure before defining tasks. Break work into bite-sized TDD steps: write the failing test, verify it fails, implement minimally, verify it passes, and commit.

What makes a good task breakdown for implementation plans?▼

Each step should be one action taking 2-5 minutes, with exact file paths, complete code blocks, exact commands, and expected outputs. Tasks must be self-contained so an engineer reading them out of order can still execute them.

When should a spec be split into multiple implementation plans?▼

Split when the spec covers multiple independent subsystems. Each plan should produce working, testable software on its own, ideally one plan per subsystem identified during the brainstorming phase.

Why do implementation plans fail during execution?▼

Plans fail when they contain placeholders like TODO or vague steps such as add error handling, reference undefined types or functions, or have inconsistent naming across tasks. A self-review for spec coverage, placeholders, and type consistency catches these issues.

What are the options for executing a finished implementation plan?▼

Two options exist: subagent-driven execution, which dispatches a fresh subagent per task with review between tasks, or inline execution, which runs tasks in the current session in batches with checkpoints for review.