writing-plans

Converts approved specs into bite-sized implementation task beads with TDD steps and acceptance criteria.

Updated Jul 22, 2026
One-click install
npx skills add https://github.com/johnstegeman/pi-packages --skill writing-plans-johnstegeman
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/johnstegeman/pi-packages/tree/main/packages/pi-superpowers-plus/skills/writing-plans
Command: npx skills add https://github.com/johnstegeman/pi-packages --skill writing-plans-johnstegeman

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Turning a specification into an actionable implementation plan is error-prone: tasks end up too large, lack tests, contain placeholders, or duplicate lifecycle steps. This Skill produces a rigorous, self-reviewed plan where every task is a small, independently testable unit stored as a bead. ## Core Features & Use Cases - Task decomposition: Breaks a spec into bite-sized tasks (2-5 minute steps) following TDD, DRY, and YAGNI principles, each with files, interfaces, and acceptance criteria. - Bead-based plan output: Creates all task beads in one beads_create_list call under the molecule's implement step, with a plan-approval gate and verdict recording. - Self-review checklist: Validates spec coverage, scans for placeholder red flags, checks type consistency, and removes lifecycle-duplicate tasks before wiring beads. - Use Case: After brainstorming produces an approved spec, use this Skill to generate an ordered set of task beads that executing-plans or subagent-driven-development can execute directly. ## Quick Start Ask the AI to use the writing-plans skill to turn the approved spec into an implementation plan of task beads.

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 spec into an implementation plan with task beads?

Claim the implement step via beads_list and beads_update, decompose the spec into bite-sized TDD tasks, then create all task beads in one beads_create_list call in plan order. The beads themselves are the plan; no separate plan document is written.

What makes a good task granularity in an implementation plan?

Each step should be one action taking 2-5 minutes, such as writing a failing test, running it, implementing minimal code, and committing. Each task ends with an independently testable deliverable a reviewer could approve or reject on its own.

Does writing-plans work with subagent-driven development?

Yes. After the plan beads and approval gate are created, you hand off the implement step id to either subagent-driven-development in the same session or executing-plans in a parallel worktree session. Both read task beads directly via beads_show.

Why must task beads be created in a single beads_create_list call?

beads_create_list creates tasks sequentially so ids come out as parent.1 through parent.N matching plan order. Multiple create calls or out-of-order tasks break the id sequence and the plan-order display in bd list and the molecule widget.

What placeholder patterns make a plan fail self-review?

Red flags include TBD or TODO markers, vague instructions like add appropriate error handling, test steps without actual test code, references to undefined types or functions, and tasks that duplicate lifecycle steps like spec approval already owned by the molecule.