writing-plans

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

1|Updated Mar 15, 2026
One-click install
npx skills add https://github.com/Luizfbm/Dev-roast --skill writing-plans-luizfbm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Luizfbm/Dev-roast/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/Luizfbm/Dev-roast --skill writing-plans-luizfbm

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of disorganized, high-level task execution by forcing a structured, TDD-based approach to software development that ensures every feature is testable and well-defined before a single line of production code is written.

Core Features & Use Cases

  • Task Decomposition: Breaks complex requirements into bite-sized, 2-5 minute actionable steps.
  • TDD Enforcement: Mandates writing failing tests before implementation to ensure code quality and reliability.
  • Review Loop: Integrates a mandatory peer-review process to catch architectural flaws early.
  • Use Case: When tasked with building a new authentication module, use this skill to map out the file structure, define the test cases for each endpoint, and generate a step-by-step checklist that prevents scope creep and ensures full test coverage.

Quick Start

Use the writing-plans skill to generate an implementation plan for the new user profile dashboard based on the provided requirements document.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create a test-driven development plan for complex feature architecture?

To create a test-driven development plan, you decompose complex features into 2-5 minute actionable steps, map specific file paths, and define failing test cases before writing production code to enforce architectural boundaries.

What is task decomposition in software development workflows?

Task decomposition is the process of breaking complex software requirements into bite-sized, granular steps. It prevents scope creep by ensuring each actionable unit is testable and well-defined before implementation begins.

How do I enforce TDD principles when building a new authentication module?

You enforce TDD principles by mandating a multi-stage review process that requires writing failing tests for each endpoint before implementation, ensuring full test coverage and catching architectural flaws early.

Does this planning approach work for managing scope creep in code development?

Yes, this planning approach manages scope creep by generating a step-by-step checklist with clear architectural boundaries and specific file path mapping, ensuring developers strictly adhere to defined requirements.

When do I need to use a structured implementation plan for software engineering?

You need a structured implementation plan for complex feature development requiring clear architectural boundaries and granular task decomposition, ensuring every feature is testable and well-defined before coding starts.

How do I integrate a mandatory peer-review loop into a development workflow?

You integrate a mandatory peer-review loop by applying a multi-stage review process during task decomposition, which catches architectural flaws early and ensures the buildability of the test-driven implementation plan.