writing-plans

Name: writing-plans
Availability: InStock
Author: ruiyangruiyi

Generate executable implementation plans with file-level scope and TDD verification.

Updated May 26, 2026

Search Tags:#workflow #tdd #documentation #implementation planning #task decomposition #codebase navigation #git commits

Ready to run

npx skills add https://github.com/ruiyangruiyi/hermes-agent --skill writing-plans-ruiyangruiyi

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/ruiyangruiyi/hermes-agent/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/ruiyangruiyi/hermes-agent --skill writing-plans-ruiyangruiyi

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the problem of unclear or overly vague development plans by turning requirements into concrete, file-specific, step-by-step tasks with testing and verification baked in.

Core Features & Use Cases

Implementation plans for unfamiliar codebases: Produces plans that assume the implementer has little context and explicitly maps what to read, change, test, and commit.
Bite-sized TDD tasks: Structures work into small 2–5 minute steps following a failing-test → minimal implementation → passing-test loop.
Execution-ready documentation: Includes exact file paths, commands, expected outcomes, and verification steps so execution is unambiguous.
Use case: Planning a multi-step feature (e.g., adding an API endpoint plus its tests and docs) while coordinating subagent-driven-development for each task.

Quick Start

Ask Hermes to write an implementation plan for your feature, including the exact files to create/modify and a TDD workflow with test and run/commit commands.

Frequently Asked Questions about writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I turn feature requirements into executable implementation steps?▼

To turn feature requirements into executable implementation steps, you can generate a plan that translates requirements into concrete, bite-sized development tasks with file-level scope and TDD verification. This maps exactly what to read, change, test, and commit.

What is the best way to plan multi-step feature delivery for an unfamiliar codebase?▼

The best way to plan multi-step feature delivery for an unfamiliar codebase is to use execution-ready documentation that assumes little context. This approach explicitly maps exact file paths, commands, expected outcomes, and verification steps so execution is unambiguous.

How do I structure task decomposition using a TDD workflow?▼

To structure task decomposition using a TDD workflow, break work into small 2–5 minute steps following a failing-test, minimal implementation, and passing-test loop. This ensures each task has testing and verification baked in.

Can I use implementation plans to coordinate subagent-driven development?▼

Yes, you can use implementation plans to coordinate subagent-driven development. The plans provide execution handoff workflows with exact paths and expected outcomes, making it easy to delegate bite-sized tasks to subagents even in context-sparse scenarios.

Does this approach provide DRY and YAGNI guidance for refactoring tasks?▼

Yes, this approach satisfies requirements for DRY and YAGNI guidance during refactoring tasks. It applies to multi-step feature delivery and refactoring by generating concrete, file-specific steps with exact run and commit commands.

When should I avoid using bite-sized implementation plans?▼

You should avoid using bite-sized implementation plans for simple, single-file edits that require no task decomposition or testing loops. The overhead of mapping exact paths, commands, and verification steps is best suited for multi-step feature delivery and context-sparse scenarios.