ZES-writing-plans

Generate structured test-driven implementation plans with file-path mappings.

Updated Jul 8, 2026
One-click install
npx skills add https://github.com/ZESCODE/Zes-Orchestration-System --skill zes-writing-plans
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ZES-writing-plans
Source: https://github.com/ZESCODE/Zes-Orchestration-System/tree/main/.agents/skills/ZES-writing-plans
Command: npx skills add https://github.com/ZESCODE/Zes-Orchestration-System --skill zes-writing-plans

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the problem of disorganized, vague, or incomplete development tasks by enforcing a rigorous, TDD-based planning process before any code is written.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into bite-sized, 2-5 minute actionable steps.
  • TDD Enforcement: Mandates the creation of failing tests before implementation to ensure code quality.
  • Use Case: When starting a new feature, use this skill to generate a structured Markdown plan that maps out file changes, test cases, and commit points, ensuring the engineer has a clear roadmap.

Quick Start

Use the ZES-writing-plans skill to generate an implementation plan for the new authentication module based on the provided requirements.

Frequently Asked Questions about ZES-writing-plans

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

FAQPage Schema
How do I create a test-driven implementation plan for a complex software feature?

To create a test-driven implementation plan, you generate a structured Markdown document that enforces TDD principles, breaking down complex features into granular 2-5 minute actionable steps with explicit file-path mapping and commit points.

What is task decomposition in software development planning?

Task decomposition in software development planning is the process of breaking complex multi-step features into bite-sized, 2-5 minute actionable steps, ensuring engineers have a clear roadmap with explicit architectural boundaries before writing any code.

How do I enforce TDD and DRY principles before writing feature code?

You enforce TDD and DRY principles by generating a rigorous implementation plan that mandates the creation of failing tests before any implementation, ensuring code quality and clear architectural boundaries for every mapped file change.

Can I use this planning approach for multi-step feature development with clear architectural boundaries?

Yes, this planning approach is specifically designed for multi-step feature development requiring clear architectural boundaries, applying granular task decomposition and explicit file-path mapping to satisfy your TDD requirements.

Does structured implementation planning work without external dependencies or frameworks?

Yes, structured implementation planning works without external dependencies, as it focuses on generating a Markdown roadmap that defines test cases and commit points rather than relying on specific frameworks or external components.

Why do I need an implementation plan when my development tasks are already defined?

You need an implementation plan to solve the problem of disorganized or vague development tasks by enforcing a rigorous TDD-based planning process, ensuring every step has explicit file-path mapping and architectural boundaries before coding begins.