writing-plans

Create implementation plans with tasks, file paths, and verification steps.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the challenge of turning complex software requirements into detailed implementation plans that developers can execute without needing extra context.

Core Features & Use Cases

  • Structured Planning: Creates bite-sized implementation tasks with exact file paths, testing steps, and verification details.
  • Development Workflow Guidance: Applies DRY, YAGNI, TDD, and frequent commit principles to organize reliable coding work.
  • Use Case: A team can use this Skill to transform a feature request into a complete engineering plan that another developer or subagent can implement step by step.

Quick Start

Use the writing-plans skill to create a detailed implementation plan for the requested software feature with tasks, files, tests, and verification steps.

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 actionable development tasks?

To break down software requirements, you create an implementation plan that decomposes complex changes into bite-sized tasks with exact file paths, testing steps, and verification details. This ensures developers can execute tasks without needing extra context.

What is an implementation plan in software engineering?

An implementation plan is a structured document that transforms complex software requirements into actionable development tasks. It includes task decomposition, exact file paths, testing guidance, and verification steps aligned with DRY, YAGNI, and TDD practices.

How do I create an engineering workflow plan that another developer can follow?

You create an engineering workflow plan by structuring tasks with exact file paths, implementation details, and testing guidance. This allows another developer or subagent to implement the software changes step by step without requiring additional context.

Does this implementation planning approach support TDD practices?

Yes, this implementation planning approach supports TDD practices by requiring testing guidance and verification steps within the task decomposition. It applies TDD alongside DRY and YAGNI principles to organize reliable coding work.

Can I use this for complex feature development and code delegation?

Yes, you can use this for complex feature development and code delegation. It applies to scenarios requiring structured task decomposition, allowing you to delegate complete engineering plans that another developer can implement step by step.

What's the best way to document engineering workflows for subagents?

The best way to document engineering workflows for subagents is creating implementation plans with structured task decomposition, exact file paths, and verification steps. This ensures subagents can execute development tasks without needing extra context.