skills.rest
MRWillisT
MRWillisTCOMMUNITY
Explore all skills by this author →
GitHub

writing-plans

Generate implementation plans with file-level tasks, tests, and commands from requirements specifications.

7|2|Updated Apr 30, 2026
Search Tags:#software engineering#writing#implementation planning#task decomposition#test planning#agent execution
One-click install
npx skills add https://github.com/MRWillisT/PullNexus --skill writing-plans-mrwillist
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/MRWillisT/PullNexus/tree/main/skills/writing-plans
Command: npx skills add https://github.com/MRWillisT/PullNexus --skill writing-plans-mrwillist

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing and planning multi-step work is slow and error-prone when the implementer lacks context, leading to missed files, weak tests, and chaotic execution.

Core Features & Use Cases

  • Context-free, engineer-ready plans that assume little to no knowledge of the codebase while still producing comprehensive, correct implementation guidance.
  • File-accurate task decomposition that maps exactly what to create or modify and includes testing and commit steps.
  • Execution-ready structure including a required plan header, a plan review loop, and a handoff path for harnesses with or without subagents.

Use case: Convert a feature spec into a step-by-step engineering plan that instructs an agent or developer exactly what to test, how to implement minimally, and how to validate with commands and expected outcomes.

Quick Start

Say: "Use the writing-plans skill to create the implementation plan for this feature spec, and save it to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md."

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn a feature spec into an actionable implementation plan?▼

An implementation plan transforms a feature spec into bite-sized, file-accurate tasks with testing steps, commands, and expected outcomes. It maps exactly what files to create or modify, ensuring context-complete guidance for developers or execution agents.

What is task decomposition in software engineering planning?▼

Task decomposition breaks multi-step engineering work into file-level modifications. It maps exactly what to create or change, includes testing and commit steps, and ensures the implementer has comprehensive guidance without needing prior codebase knowledge.

How do I write implementation plans for agent execution?▼

Write execution-ready plans with a required plan header, bite-sized task granularity, and explicit test commands. Include a review loop and handoff path to guide agents or developers through minimal implementation and validation steps.

Can I use implementation plans for refactoring existing code?▼

Implementation plans apply to new features, refactors, and changes requiring file-level decomposition. They produce context-complete guidance with testing steps and a review-and-handoff workflow, suitable for any multi-step engineering work.

What's the best way to structure an implementation plan for a developer handoff?▼

Structure plans with a required header, bite-sized tasks including tests and commands, and a saved output location. Include a plan review loop and an optional subagent-driven execution path to ensure smooth handoff and validation.

Do I need prior codebase knowledge to follow an implementation plan?▼

No, implementation plans are context-free and engineer-ready. They assume little to no knowledge of the codebase while still providing comprehensive, correct implementation guidance with file-accurate decomposition and testing steps.

Related Skills

Explore More Software Engineering Skills→
kaptinlinkaptinlin
23

tdd-planning

Generate a TDD implementation plan from a PRD or design document.

Community
Advanced
TumeloRamaphosaTumeloRamaphosa

writing-plans

Convert implementation specifications into decomposed, testable task plans.

Community
Advanced
SkogAISkogAI
1

writing-plans

Generate detailed implementation plans with file paths, code samples, and tests.

Official
Advanced
guccangguccang
3

subagent-driven-development

Coordinate software implementation tasks through delegated subagents and structured review workflows.

Community
Advanced