writing-plans

Convert feature specifications into engineer-executable implementation plans with file touchpoints.

17|Updated Feb 19, 2026
One-click install
npx skills add https://github.com/ivanrvpereira/.agents --skill writing-plans-ivanrvpereira
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/ivanrvpereira/.agents/tree/main/skills/writing-plans
Command: npx skills add https://github.com/ivanrvpereira/.agents --skill writing-plans-ivanrvpereira

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

writing-plans converts a multi-step spec into a concrete, buildable implementation plan that an engineer can follow even with limited codebase context.

Core Features & Use Cases

  • Multi-step task decomposition: Breaks work into bite-sized, test-driven actions with clear component boundaries.
  • File-focused guidance: Specifies exact create/modify/test paths so implementation has minimal ambiguity.
  • Plan-ready execution handoff: Produces a plan that can be executed inline or handed off to subagents task-by-task.
  • Anti-placeholder guardrails: Prohibits TODO/TBD-style gaps and requires code blocks and exact commands.

Quick Start

Use the writing-plans skill to generate a dated implementation plan saved under docs/superpowers/plans/ based on your feature spec.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I convert a feature specification into a step-by-step implementation plan?

Converting a feature specification into an implementation plan requires decomposing multi-step work into bite-sized, test-driven actions with exact file touchpoints. This produces a buildable plan with minimal ambiguity for engineers to execute.

What is task decomposition in test-driven development planning?

Task decomposition in TDD planning breaks multi-step development work into bite-sized, test-driven actions with clear component boundaries. It specifies exact create, modify, and test paths so implementation follows a predetermined execution sequence.

How do I create an engineering handoff plan with exact file touchpoints?

Creating an engineering handoff plan involves converting feature specs into a dated document specifying exact create, modify, and test paths. The plan must contain bite-sized TDD tasks, exact commands, and code blocks while prohibiting TODO-style gaps.

Do I need a structured spec format to generate a TDD implementation plan?

You need a structured feature specification to generate a TDD implementation plan, as the process requires upfront architecture and testing strategy definition. The input spec provides the context necessary to determine execution sequence before changing code.

Can I execute implementation plans inline or hand them off to subagents task-by-task?

Implementation plans can be executed inline or handed off to subagents task-by-task. The plan-ready format supports both direct execution and sequential delegation by producing discrete, engineer-executable steps with clear component boundaries.

How to avoid TODO placeholders and gaps in engineering documentation?

To avoid TODO placeholders and gaps in engineering documentation, enforce anti-placeholder guardrails that prohibit TBD-style gaps. Plans must require concrete code blocks and exact testing commands instead of leaving undefined implementation steps.