writing-plans

Generate step-by-step implementation plans with TDD tasks from requirements specs.

1|Updated Apr 14, 2026
One-click install
npx skills add https://github.com/eddielueng/hermes-agent-zh --skill writing-plans-eddielueng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/eddielueng/hermes-agent-zh/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/eddielueng/hermes-agent-zh --skill writing-plans-eddielueng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing unclear, under-specified development plans causes wasted time, missing details, and implementation mistakes when multiple steps and file-level changes are required.

Core Features & Use Cases

  • Comprehensive implementation planning from scratch: Produces a plan that assumes the implementer has little to no context and may have questionable taste, ensuring every needed detail is captured.
  • Bite-sized, TDD-oriented tasks: Breaks work into 2–5 minute tasks with a full failing-test → implement → passing-test cycle and explicit commit points.
  • Actionable codebase navigation: Guides the planner to inspect the repository structure, find analogous patterns, and reference key existing files and tests using Hermes tools.
  • Execution-ready output: Provides exact file paths, copy-pasteable code examples, exact test commands, and verification steps so implementation is obvious.

Example: You receive a feature spec for a multi-step backend change (new endpoints, validation, and tests) but no one knows the current code structure—use this skill to generate an end-to-end plan that specifies exactly what to create/modify, how to test each incrementally, and what to commit.

Quick Start

Ask Hermes: "Create an implementation plan for [describe feature/spec], including bite-sized TDD tasks with exact file paths, test commands, verification steps, and commit messages."

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate a step-by-step implementation plan from a feature spec?

To generate an implementation plan, provide the feature spec to the Skill. It breaks the work into bite-sized, TDD-oriented tasks with exact file paths, test commands, and verification steps.

What is the best way to plan a multi-step software refactor with unknown codebase context?

Planning a multi-step software refactor requires navigating the repository to find analogous patterns. The Skill inspects the repository structure and generates an ordered plan with explicit commit points and spec compliance.

How to break down a complex backend change into bite-sized TDD tasks?

Breaking down a backend change involves creating 2–5 minute tasks following a failing-test, implement, passing-test cycle. The Skill outputs this structure with copy-pasteable code examples and commit messages.

Can I use this approach to plan subagent-driven development for feature work?

Yes, you can use this approach for subagent-driven development. The Skill produces an execution handoff that delegates per task, ensuring each subagent receives exact paths, commands, and DRY/YAGNI guidance.

Does implementation planning work when I only have partial codebase knowledge?

Implementation planning works with partial codebase knowledge by guiding you to inspect the repository structure and reference key existing files. It assumes the implementer has little to no context and captures every needed detail.

When should I not use an automated implementation plan for software design?

You should not use an automated implementation plan if your software design requires exploratory prototyping rather than strict task decomposition. The Skill enforces TDD principles and structured execution handoffs, which may limit open-ended exploration.