writing-plans

Generates bite-sized, test-driven implementation plans from specs for multi-step coding tasks.

9|1|Updated Aug 28, 2026
One-click install
npx skills add https://github.com/RisorseArtificiali/skills --skill writing-plans-risorseartificiali
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/RisorseArtificiali/skills/tree/main/forked/writing-plans
Command: npx skills add https://github.com/RisorseArtificiali/skills --skill writing-plans-risorseartificiali

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an executable implementation plan is error-prone: tasks end up too vague, placeholders slip in, and engineers (or subagents) with zero codebase context get stuck. This Skill produces a complete, self-contained plan where every task has exact file paths, real code snippets, test commands, and commit steps. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into tasks with 2-5 minute steps following a TDD cycle (failing test, minimal implementation, verification, commit). - Deviation Protocol: Instructs executors to stop and report when reality diverges from the plan instead of improvising fixes, preventing compounding rework. - No-Placeholder Enforcement & Self-Review: Bans TODOs and vague steps, then runs a checklist for spec coverage, placeholder scans, and type consistency across tasks. - Use Case: After brainstorming a new feature, feed the approved spec to this Skill to produce a dated plan document in docs/superpowers/plans/, ready for subagent-driven or inline execution. ## Quick Start Use the writing-plans skill to turn this feature spec into a step-by-step implementation plan with tests and commits.

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?▼

Map out the file structure first, then decompose the spec into tasks where each task has exact files to create or modify, interface contracts, guardrails, and bite-sized TDD steps ending in a commit. Finish with a self-review checking spec coverage and type consistency.

How to break a coding task into steps for AI subagents?▼

Make each step a single 2-5 minute action: write the failing test, run it to confirm failure, implement minimal code, verify it passes, then commit. Each task must be self-contained since a subagent sees only its own task, so include interfaces and guardrails verbatim.

What should an implementation plan template include?▼

A header with goal, architecture, tech stack, and global constraints; a deviation protocol telling executors to stop and report mismatches; and per-task sections listing files, interfaces consumed and produced, guardrails, and checkbox steps with real code and test commands.

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; if subsystems were not separated during brainstorming, create one plan per subsystem rather than one monolithic plan.

What happens when plan execution deviates from the written steps?▼

The deviation protocol requires the executor to stop the task immediately, never improvise a fix or skip ahead. They report which step failed, expected versus observed results, and the smallest question whose answer unblocks them.