skills.rest
carterwayneskhizeine
carterwayneskhizeineCOMMUNITY
Explore all skills by this author →
GitHub

writing-plans

Generate execution-ready implementation plans with file-specific TDD task sequences.

19|4|Updated Apr 22, 2026
Search Tags:#tdd#documentation#implementation planning#developer workflow#task breakdown#codebase navigation#subagent coordination
One-click install
npx skills add https://github.com/carterwayneskhizeine/hermes-agent-windows-R --skill writing-plans-carterwayneskhizeine
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/carterwayneskhizeine/hermes-agent-windows-R/tree/main/skills/software-development/writing-plans
Command: npx skills add https://github.com/carterwayneskhizeine/hermes-agent-windows-R --skill writing-plans-carterwayneskhizeine

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

writing-plans helps you avoid vague, incomplete implementation directions by producing execution-ready plans that make the next code changes obvious, even for someone with little context.

Core Features & Use Cases

  • Bite-sized, TDD-friendly tasks: Breaks work into 2–5 minute steps that include failing-test, run-to-verify, minimal implementation, and passing-test verification.
  • Exact file paths and verification: Forces plans to specify create/modify/test paths, include copy-pasteable code snippets, and provide concrete commands with expected outcomes.
  • Codebase onboarding for implementers: Guides the planner to explore the repository structure, discover existing patterns/tests, and document what must be checked before coding.
  • Useful for delegating work: Designed to hand off task-by-task execution with spec compliance and code quality review after each step.

Examples Use Cases

Use this when you need to implement multi-step Windows Agent features, refactor a subsystem safely with tests, or coordinate multiple changes across docs, code, and tooling without losing correctness.

Quick Start

Ask the AI to write an implementation plan for your target feature with exact file paths, bite-sized tasks, full TDD cycles per task, and explicit 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 task plans?▼

Executable task plans are generated by translating software requirements into file-specific, context-light task sequences. This process enforces test-driven steps with concrete commands, exact file paths, and explicit verification expectations for each 2-5 minute implementation cycle.

What is the best way to delegate implementation plans to subagents?▼

Delegating implementation plans to subagents requires context-light, file-specific task sequences with independent verification steps. The plan guides subagent coordination by enforcing DRY, YAGNI, and TDD cycles with copy-pasteable code snippets and expected command outcomes.

How do I write a TDD implementation plan for a codebase refactoring?▼

Writing a TDD implementation plan for codebase refactoring involves breaking work into bite-sized tasks that include failing-test creation, run-to-verify checks, minimal implementation, and passing-test verification. The plan specifies exact modify and test paths with concrete commands.

Does this implementation planning approach work for multi-step feature development?▼

Implementation planning applies directly to multi-step feature development by producing execution-ready, YAML-discoverable planning metadata. It guides codebase onboarding to discover existing patterns and translates feature requirements into step-by-step, independently verifiable implementation directions.

Why do my developer workflow task plans lack specific verification steps?▼

Developer workflow task plans often lack verification steps when they fail to enforce test-driven development cycles and concrete command expectations. Execution-ready plans must specify exact create, modify, and test paths alongside copy-pasteable code snippets and explicit verification commands.

When should I not use bite-sized task breakdown for implementation?▼

Bite-sized task breakdown for implementation is not suited for vague architectural spikes lacking testable outcomes or single-file edits requiring no delegation. It is designed for multi-step refactoring, feature implementation, and subagent coordination where each step must be independently verifiable.

Related Skills

Explore More Software Engineering Skills→
normcrandallnormcrandall
1

coding-standards

Analyze project configurations and code patterns to generate coding-standards.md.

Community
Basic
danger-Englishdanger-English
2

subagent-driven-development

Dispatch fresh subagents for isolated tasks with two-stage reviews.

Community
Advanced
lpjhelderlpjhelder

tdd

Enforce failing tests before production code across RED, GREEN, and REFACTOR phases.

Community
Intermediate
blundergoatblundergoat

goat-plan

Break down software implementation tasks into risk-weighted milestones with verification gates.

Official
Advanced