writing-plans

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

Updated May 4, 2026
One-click install
npx skills add https://github.com/Junkfooooood/hermes-governance --skill writing-plans-junkfooooood
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Junkfooooood/hermes-governance/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/Junkfooooood/hermes-governance --skill writing-plans-junkfooooood

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Implementation work often fails because plans are vague, missing file paths, or lack complete code, forcing implementers to guess. This Skill produces detailed implementation plans that make execution obvious even for someone with zero codebase context. ## Core Features & Use Cases - Bite-Sized Task Breakdown: Splits features into 2-5 minute tasks, each with failing test, minimal implementation, verification, and commit steps. - Complete Plan Templates: Enforces a required header, exact file paths, copy-pasteable code, and commands with expected output. - TDD and Execution Handoff: Embeds DRY, YAGNI, and test-driven development principles, then hands off to subagent-driven-development for task-by-task execution. - Use Case: Before building a multi-step feature like user authentication, generate a plan where each task specifies the exact test file, model code, pytest command, and git commit message. ## Quick Start Ask the agent to write an implementation plan for your feature, breaking it into bite-sized TDD tasks with exact file paths and complete 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 for a new feature?

Start with a header stating goal, architecture, and tech stack, then break the work into tasks of 2-5 minutes each. Every task lists exact files, a failing test, minimal implementation, run 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, such as writing one failing test or adding one small function. Large items like 'build authentication' should be split into separate tasks for the model, hashing utility, and tests.

Should I write a plan before implementing code myself?

Yes. The skill recommends planning even for solo or simple-seeming work, because assumptions cause bugs and documentation helps future you. A good plan makes implementation obvious without guessing.

What are common mistakes when writing implementation plans?

Common mistakes include vague tasks, incomplete code snippets, missing verification steps, and unspecified file paths. Each task needs copy-pasteable code, exact commands with expected output, and precise paths like src/models/user.py.

When should I not use a detailed implementation plan?

The skill argues plans should rarely be skipped, but they are designed for multi-step features and subagent delegation. Trivial one-line changes may not justify the full plan structure with TDD cycles and commit steps.