writing-plans

Writes structured implementation plans with bite-sized TDD tasks from specs or requirements.

1|Updated May 6, 2026
One-click install
npx skills add https://github.com/surfingalien/FinSurfing --skill writing-plans-surfingalien
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/surfingalien/FinSurfing/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/surfingalien/FinSurfing --skill writing-plans-surfingalien

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or feature idea into code without a plan leads to missed requirements, inconsistent structure, and wasted effort. This Skill converts specs, requirements docs, or feature descriptions into detailed, step-by-step implementation plans that an engineer with zero codebase context can execute reliably. ## Core Features & Use Cases - Bite-Sized Task Breakdown: Splits work into 2-5 minute steps following a TDD cycle: write failing test, verify failure, implement, verify pass, commit. - Concrete Plan Documents: Every task includes exact file paths, complete code blocks, exact commands with expected output, and line numbers for modifications. - Pitfall Guidance: Built-in rules prevent abstract steps, wrong granularity, missing verification, DRY violations, and assumed context. - Execution Handoff: After saving the plan to docs/plans/, offers subagent-driven or parallel-session execution via the executing-plans skill. - Use Case: Given a feature request like "add email validation to the signup API", produce a dated plan file with per-task tests, code, commands, and commits ready for execution. ## Quick Start Ask the AI to write an implementation plan for your feature spec before any code is written.

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 before coding?

Provide a spec, requirements doc, or feature description and ask for an implementation plan. The output is a Markdown document with a goal, architecture summary, tech stack, and numbered tasks containing exact file paths, code, test commands, and commit steps.

What makes a good implementation plan for engineers?

A good plan uses exact file paths, complete code blocks instead of pseudocode, exact commands with expected output, and 2-5 minute steps that each produce a committable change. It assumes the engineer has no prior context about the codebase or conventions.

How granular should tasks be in a coding plan?

Each step should take 2-5 minutes and produce one verifiable, committable change, such as writing a failing test, implementing minimal code to pass it, or committing. Avoid both vague epics and micro-steps like single import statements.

Where are implementation plans saved?

Plans are saved as Markdown files under docs/plans/ using the naming pattern YYYY-MM-DD-<feature-name>.md. Each plan starts with a header stating the goal, architecture, tech stack, and a pointer to the executing-plans skill.

When should I not write a full implementation plan?

Skip the planning step for trivial single-file changes or quick fixes where a plan adds overhead without value. The skill targets multi-step coding tasks where requirements, testing, and verification need to be documented upfront.