writing-plans

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

Updated May 3, 2026
One-click install
npx skills add https://github.com/80portisfound/vibe-learning --skill writing-plans-80portisfound
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/80portisfound/vibe-learning/tree/main/packages/hermes/skills/software-development/writing-plans
Command: npx skills add https://github.com/80portisfound/vibe-learning --skill writing-plans-80portisfound

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 one action such as writing a failing test, running it, implementing minimal code, and committing. - Complete Task Specifications: Every task includes exact file paths, copy-pasteable code, exact commands with expected output, and verification steps. - TDD and Commit Discipline: Enforces test-driven development cycles, DRY and YAGNI principles, and frequent commits after each task. - 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 a password hash field, and writing a hashing utility, each with tests and commit steps. ## Quick Start Ask the agent to write an implementation plan for your feature following the writing-plans structure with bite-sized TDD tasks and exact file paths.

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 software feature?▼

Start with a header stating the goal, architecture, and tech stack, then break the work into tasks of 2-5 minutes each. Every task needs exact file paths, complete copy-pasteable code, exact commands with expected output, and a commit step.

How granular should tasks be in an implementation plan?▼

Each task should represent 2-5 minutes of focused work with a single action, such as writing one failing test or adding one field to a model. Large tasks like building an entire authentication system should be split into separate model, utility, and test tasks.

Should implementation plans include test-driven development steps?▼

Yes, every code-producing task should follow the full TDD cycle: write a failing test, run it to verify failure, write minimal implementation code, then run the test to verify it passes. This catches design errors before implementation.

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 multi-step features and subagent delegation.

What are common mistakes in implementation plans?▼

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