writing-plans

Generate implementation plans with task decomposition and TDD workflows.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of disorganized or incomplete development by forcing a rigorous, step-by-step 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 writing failing tests before implementation to ensure code quality.
  • Use Case: When starting a new feature, use this skill to map out file modifications, test cases, and commit points to ensure the implementation is modular and testable.

Quick Start

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

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate a TDD-ready implementation plan for feature development?

A TDD-ready implementation plan breaks complex features into 2-5 minute actionable steps with specific file modifications, test cases, and commit points mapped out. This forces a rigorous planning process before code is written to ensure modular, testable implementations.

What is task decomposition in software development planning?

Task decomposition breaks complex features into bite-sized, 2-5 minute actionable steps. It solves disorganized development by mandating a step-by-step planning process that maps out file modifications, test cases, and commit points before any code is written.

How do I structure a test-first workflow for refactoring scenarios?

To structure a test-first workflow for refactoring scenarios, apply a planning process that mandates writing failing tests before implementation. The workflow requires precise file-level instructions and frequent commit cycles to ensure code quality and modular task decomposition.

Can I use this implementation planning approach for multi-step development tasks?

Yes, this implementation planning approach applies to multi-step development tasks including feature development and refactoring scenarios. It generates comprehensive plans requiring clear task decomposition and TDD practices to satisfy precise file-level instructions and frequent commit cycles.

What's the best way to enforce TDD practices during code implementation?

The best way to enforce TDD practices is to generate a structured implementation plan that mandates writing failing tests before implementation. This ensures code quality by mapping out test cases, specific file modifications, and frequent commit cycles before coding begins.

Why does disorganized development happen and how can planning prevent it?

Disorganized development happens due to incomplete or absent planning before coding. A rigorous, step-by-step planning process prevents it by decomposing tasks into 2-5 minute actionable steps, mapping file modifications, test cases, and frequent commit cycles to enforce test-first workflows.