writing-plans

Generates detailed multi-task implementation plans with TDD steps from feature specifications.

Updated Aug 3, 2026
One-click install
npx skills add https://github.com/Yvesdefaria/GymLab --skill writing-plans-yvesdefaria
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Yvesdefaria/GymLab/tree/main/gymlab-app/.agents/skills/writing-plans
Command: npx skills add https://github.com/Yvesdefaria/GymLab --skill writing-plans-yvesdefaria

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, inconsistent types across tasks, and vague steps that stall implementation. This Skill converts a spec or requirements document into a complete, bite-sized implementation plan that an engineer with zero codebase context can execute task by task. ## Core Features & Use Cases - Structured Plan Documents: Produces plans 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: Breaks work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps following the failing-test, implement, verify, commit cycle. - Placeholder-Free Enforcement: Forbids TODOs and vague steps, requiring actual code blocks in every step, plus a self-review pass for spec coverage, placeholders, and type consistency. - Execution Handoff: Offers subagent-driven or inline execution after the plan is saved, with a reviewer prompt template for validating the finished plan. - Use Case: Given a spec for a new workout logging feature, produce a plan where each task lists exact files to create or modify, the test code to write first, the minimal implementation, run commands with expected output, and a commit step. ## Quick Start Ask the agent 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 a header covering goal, architecture, tech stack, and spec path, then decompose the work into tasks with exact file paths and interface contracts. Each task contains bite-sized TDD steps: write the failing test, verify it fails, implement minimally, verify it passes, and commit.

How to break a large feature into implementation tasks?

Map the file structure first, assigning one clear responsibility per file, then draw task boundaries where a reviewer could reject one task while approving its neighbor. Fold setup and scaffolding into the task whose deliverable needs them, and split multi-subsystem specs into separate plans.

What makes a good task granularity in a coding plan?

Each step should be one action taking 2-5 minutes, such as writing a failing test or running it to confirm failure. Each task must end with an independently testable deliverable and include exact run commands with expected output.

When should a spec be split into multiple implementation plans?

Split when the spec covers multiple independent subsystems that should have been separated during brainstorming. Each resulting plan should produce working, testable software on its own rather than depending on sibling plans.

What are common mistakes in AI-generated implementation plans?

Common failures include placeholders like TODO or 'add error handling', steps describing what to do without showing code, references to undefined types, and inconsistent function names across tasks. A self-review pass checking spec coverage, placeholders, and type consistency catches these before execution.