writing-plans

Convert software requirements into executable implementation plans with file-level specificity.

Updated May 10, 2026
One-click install
npx skills add https://github.com/Mateus2411/Hermes-PersonalBot --skill writing-plans-mateus2411
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Mateus2411/Hermes-PersonalBot/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/Mateus2411/Hermes-PersonalBot --skill writing-plans-mateus2411

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents stalled or buggy implementations by turning unclear requirements into a step-by-step plan that an engineer can execute with minimal guesswork.

Core Features & Use Cases

  • Bite-sized implementation plans that break work into 2–5 minute tasks suitable for sequential execution.
  • Explicit file paths, complete code blocks, and exact commands so implementers can proceed without searching for missing context.
  • TDD-oriented task framing (write failing test → verify failure → minimal implementation → verify pass → commit) to reduce regression risk.
  • Use-case coverage for multi-step features, delegated work via subagents, and situations where the implementer has little domain context.

Quick Start

Ask Hermes to create an implementation plan for your feature and require exact file paths, a TDD loop per task, and copy-paste-ready verification commands.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down software requirements into executable implementation plans?

Implementation plans are broken down into bite-sized 2–5 minute tasks with explicit file paths, complete code blocks, and exact verification commands. This prevents stalled implementations by ensuring engineers can proceed with minimal guesswork and without searching for missing context.

How does test-driven development task framing work for implementation planning?

Test-driven development task framing structures each implementation step as a loop: write a failing test, verify the failure, write the minimal implementation, verify the pass, and commit. This TDD-oriented task framing reduces regression risk during feature development and multi-step refactors.

Can I use this implementation planning approach for subagent task handoffs?

Yes, implementation planning is specifically designed for delegated work via subagents and situations where the implementer lacks codebase context. It provides file-level specificity and exact commands so subagents can execute tasks without needing domain context or manual codebase navigation.

What's the best way to create a step-by-step plan for a multi-step feature refactor?

The best way to plan a multi-step refactor is to generate bite-sized, sequential tasks that include exact file paths, copy-paste-ready verification commands, and DRY/YAGNI guidance. This makes the implementation unambiguous and suitable for frequent commits throughout the refactor cycle.

Do I need prior codebase context to follow an executable implementation plan?

No, you do not need prior codebase context. The plan provides file-level specificity, complete code blocks, and exact commands so implementers can proceed without searching for missing context or needing deep domain knowledge to navigate the codebase.