writing-plans

Write implementation plans with bite-sized tasks, exact file paths, and complete code.

Updated May 13, 2026
One-click install
npx skills add https://github.com/superfhp/lumi-agent-body --skill writing-plans-superfhp
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/superfhp/lumi-agent-body/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/superfhp/lumi-agent-body --skill writing-plans-superfhp

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Vague or incomplete implementation plans force developers to guess at file paths, code details, and verification steps, causing bugs and rework. This Skill produces plans so detailed that an implementer with zero codebase context can execute them directly. ## Core Features & Use Cases - Bite-Sized Task Breakdown: Splits features into 2-5 minute tasks, each with exact file paths, complete copy-pasteable code, and exact commands with expected output. - TDD-Structured Tasks: Every coding task follows the full test-driven cycle: write failing test, verify failure, implement minimal code, verify pass, commit. - Execution Handoff: Saved plans integrate with subagent-driven-development for task-by-task execution with spec compliance and code quality reviews. - Use Case: Before building a multi-step feature like user authentication, generate a plan that decomposes it into tasks such as creating the User model, adding password hashing, and writing tests, each with exact paths and commands. ## Quick Start Ask the agent to write an implementation plan for your feature, breaking it into small TDD tasks with exact file paths and complete code, saved to docs/plans.

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 for a new feature?▼

Start by understanding requirements and exploring the codebase, then design the approach and write sequential tasks. Each task needs exact file paths, complete code examples, exact commands with expected output, and a commit step.

How granular should tasks be in an implementation plan?▼

Each task should take 2-5 minutes of focused work, with every step being a single action like writing a failing test or committing. Large tasks like 'build authentication' should be split into small units such as creating one model or one utility.

Should implementation plans include test-driven development steps?▼

Yes, every task that produces code should follow the full TDD cycle: write a failing test, run it to verify failure, write minimal implementation code, run tests to verify they pass, then commit the changes.

When should I skip writing an implementation plan?▼

You should not skip planning even for simple features, solo work, or self-implementation, since assumptions cause bugs and future maintainers need guidance. Plans are especially required before delegating tasks to subagents.

What are common mistakes in implementation plans?▼

Common mistakes include vague tasks like 'add authentication', incomplete code snippets, missing verification steps with expected output, and unspecified file paths. A good plan makes implementation obvious with no guessing required.