writing-plans

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

Updated Jul 9, 2026
One-click install
npx skills add https://github.com/assafmanor/waypoint --skill writing-plans-assafmanor
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/assafmanor/waypoint/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/assafmanor/waypoint --skill writing-plans-assafmanor

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often start coding from a spec without a concrete plan, leading to missed requirements, inconsistent types across tasks, and vague steps that stall implementation. This Skill turns a spec or requirements document into a complete, executable implementation plan that an engineer with zero codebase context can follow task by task. ## Core Features & Use Cases - Structured Plan Generation: Produces a plan document with a mandatory header (goal, architecture, tech stack, spec reference, global constraints) saved to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md. - Bite-Sized TDD Tasks: Decomposes work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps following the write-failing-test, run, implement, verify, commit cycle. - Quality Gates: Enforces a no-placeholder policy, a self-review checklist (spec coverage, placeholder scan, type consistency), and an optional plan document reviewer subagent prompt. - Use Case: Given a spec for a new trip-itinerary feature, produce a plan where each task lists exact files to create or modify, real test code, run commands with expected output, and commit commands, then hand off to subagent-driven or inline execution. ## Quick Start Ask the AI to use the writing-plans skill to create an implementation plan from your spec document before writing any code.

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 the spec, map out which files will be created or modified, then decompose the work into tasks with exact file paths and interface contracts. Each task contains bite-sized steps: write a failing test, run it, implement minimal code, verify it passes, and commit.

What is the right task granularity for an implementation plan?▼

A task is the smallest unit carrying its own test cycle and worth a fresh reviewer's gate. Fold setup and scaffolding into the task whose deliverable needs them, and split only where a reviewer could reject one task while approving its neighbor.

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, so one plan per subsystem keeps scope reviewable and executable.

Why do implementation plans fail during execution?▼

Plans fail when they contain placeholders like TODO or vague steps such as add error handling, or when type and function names drift between tasks. The self-review checklist catches spec gaps, placeholder patterns, and type inconsistencies before handoff.

Can a subagent review the plan document before execution?▼

Yes, the skill includes a plan document reviewer prompt template for dispatching a general-purpose subagent. It checks completeness, spec alignment, task decomposition, and buildability, returning a status of Approved or Issues Found.