writing-plans

Name: writing-plans
Availability: InStock
Author: zerwiz

Creates implementation plans with tasks, code examples, and verification commands.

1|Updated Apr 10, 2026

Search Tags:#planning #testing #tdd #documentation #implementation #subagents

Ready to run

npx skills add https://github.com/zerwiz/wayofpi --skill writing-plans-zerwiz

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you turn a vague specification or multi-step request into a precise, executable implementation plan, so the work is easy to understand and hard to get wrong.

Core Features & Use Cases

Detailed Task Breakdown: Splits complex work into small, sequential tasks that are easy to assign and complete.
Exact Implementation Guidance: Includes specific file paths, complete code examples, and verification commands so there is no guesswork.
Plan for Delegation: Ideal for features, refactors, or cross-file changes where an implementer needs full context and a clear test-first path.
Use Case: A product team asks for a new workflow, and the Skill produces a step-by-step build plan that a developer can follow from tests to final commit.

Quick Start

Ask the skill to create a detailed implementation plan for your feature request, including the exact files to change, the test strategy, and how to verify completion.

Frequently Asked Questions about writing-plans

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

FAQPage Schema

How do I create an implementation plan for complex software features?▼

An implementation plan for multi-step work should include bite-sized tasks, exact file paths, copy-pasteable code examples, and verification commands. This ensures complex software features are broken down into clear, sequential steps that are easy to assign and hard to get wrong.

What is test-first task breakdown in software planning?▼

Test-first task breakdown structures feature development by sequencing the test strategy before the final commit. It provides a clear path for implementers by defining specific file changes, complete code examples, and verification commands upfront in the implementation plan.

How do I plan refactoring tasks for delegated developers?▼

Plan refactoring tasks for delegated developers by providing structured handoff guidance with full context, exact file paths, and a clear test-first path. This ensures cross-file changes are executed sequentially with copy-pasteable code examples and verification commands.

Does implementation planning work for cross-file changes and refactors?▼

Yes, implementation planning works for cross-file changes and refactors by splitting complex work into small, sequential tasks. It includes exact file paths, complete code examples, and verification commands, making it ideal for delegated tasks requiring full context and clear sequencing.

What's the best way to turn vague specifications into executable software plans?▼

The best way to turn vague specifications into executable software plans is to generate a step-by-step build plan with detailed task breakdowns. This includes exact implementation guidance like specific file paths, complete code examples, and verification commands to eliminate guesswork.

When do I need a detailed implementation plan for software development?▼

You need a detailed implementation plan for software development when handling multi-step work, feature development, or refactors that require clear sequencing and delegation. It ensures exact file paths, test-first breakdowns, and structured handoff guidance are established before coding begins.