skills.rest
CYRUS-pinto
CYRUS-pintoCOMMUNITY
Explore all skills by this author →
GitHub

writing-plans

Generates detailed multi-task implementation plans from specs with TDD steps and exact file paths.

Updated Sep 11, 2026
Search Tags:#planning#tdd#code generation#implementation plan#task decomposition#spec#subagent
One-click install
npx skills add https://github.com/CYRUS-pinto/pi-bot --skill writing-plans-cyrus-pinto
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/CYRUS-pinto/pi-bot/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/CYRUS-pinto/pi-bot --skill writing-plans-cyrus-pinto

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an actionable implementation plan is error-prone: tasks end up too vague, placeholders slip in, and engineers without codebase context get stuck. This Skill produces a complete, bite-sized task breakdown that an engineer with zero project context can execute directly. ## Core Features & Use Cases - Structured Plan Documents: Generates plans with a mandatory header (goal, architecture, tech stack, spec link, global constraints) saved to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md. - Bite-Sized TDD Tasks: Breaks work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps covering failing test, implementation, verification, and commit. - Self-Review and Handoff: Runs a spec-coverage, placeholder, and type-consistency check, then offers subagent-driven or inline execution of the finished plan. - Use Case: Given a feature spec for a new API endpoint, produce a plan where each task lists the exact files to create or modify, the test code to write first, the commands to run, and the commit message to use. ## Quick Start Ask the agent to use the writing-plans skill to turn your spec document into a step-by-step implementation plan 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 spec before coding?▼

Provide the spec and invoke the writing-plans skill before touching code. It maps the file structure, decomposes work into right-sized tasks with exact paths, and writes each step as a 2-5 minute TDD action ending in a commit.

What makes a good task breakdown for an implementation plan?▼

Each task should be the smallest unit with its own test cycle and an independently testable deliverable. Fold setup and scaffolding into the task that needs them, and split only where a reviewer could reject one task while approving its neighbor.

How granular should steps be in a coding plan?▼

Each step should be one action taking 2-5 minutes: write the failing test, run it to confirm failure, implement minimal code, run tests to confirm passing, then commit. Every code step must include the actual code, not a description.

Can the generated plan be executed automatically by subagents?▼

Yes. After saving the plan, the skill offers subagent-driven execution, which dispatches a fresh subagent per task with two-stage review, or inline execution with batched tasks and checkpoints.

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.

Related Skills

Explore More Software Engineering Skills→
RamachandrajoshiRamachandrajoshi

writing-plans

Generate implementation plans from formal specs before coding.

Community
Advanced
overtimepogovertimepog

subagent-driven-development

Execute implementation plans by dispatching fresh subagents per task with mandatory code reviews.

Community
Basic
danilonovaisvdanilonovaisv
1

using-git-worktrees

Create isolated git worktrees for each feature branch.

Community
Intermediate
mst-software-vnmst-software-vn
1

writing-plans

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

Official
Intermediate