writing-plans

Generate structured, test-driven implementation plans for software development tasks.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the problem of disorganized or incomplete development by enforcing a structured, test-driven approach to feature implementation before any code is written.

Core Features & Use Cases

  • TDD Enforcement: Mandates the creation of failing tests before implementation to ensure code quality and reliability.
  • Bite-Sized Tasking: Breaks complex features into granular, 2-5 minute actionable steps to maintain momentum and focus.
  • Use Case: When starting a new feature, use this Skill to generate a comprehensive roadmap that guides an engineer through architecture, test design, and implementation, ensuring every step is verified and committed.

Quick Start

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

Frequently Asked Questions about writing-plans

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

FAQPage Schema
What is a TDD-ready implementation plan for software development?

A TDD-ready implementation plan is a structured roadmap that breaks complex features into granular tasks, mandating failing tests before code implementation to ensure architectural clarity and software reliability.

How do I break down complex software features into actionable development steps?

To break down complex software features, generate a structured plan that divides overarching architecture into bite-sized, 2-5 minute actionable steps, ensuring systematic documentation and clear execution instructions for subagents.

Does test-driven development planning require adherence to DRY and YAGNI principles?

Yes, test-driven development planning requires strict adherence to DRY and YAGNI principles to prevent code bloat, ensuring the generated architectural workflow only includes necessary components for reliable implementation.

What is the best way to enforce a test-driven workflow before writing feature code?

The best way to enforce a test-driven workflow is using a structured planning skill that mandates the creation of failing tests prior to implementation, providing a step-by-step execution roadmap for engineers and subagents.

Can I use this structured planning approach for large-scale architecture tasks?

Yes, this structured planning approach applies to complex feature development requiring granular task breakdown and systematic documentation, guiding engineers through architecture design and test implementation for large-scale tasks.

When should I avoid generating granular task breakdowns for development?

You should avoid generating granular task breakdowns for simple modifications that do not require architectural clarity, TDD workflows, or systematic documentation, as the overhead of 2-5 minute step generation is unnecessary for trivial updates.