writing-plans

Generate test-driven implementation plans with granular task decomposition for software features.

Updated Nov 23, 2025
One-click install
npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill writing-plans-manuelbrandner85
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/manuelbrandner85/Weltenbibliothekapp/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill writing-plans-manuelbrandner85

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of disorganized or incomplete development by forcing a rigorous, test-driven planning phase before any code is written, ensuring developers have clear, bite-sized tasks.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into granular, 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 comprehensive plan that maps out file changes, test requirements, and commit points, preventing scope creep and architectural drift.

Quick Start

Use the writing-plans skill to create 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 break down complex software features into actionable TDD implementation plans?

To create a TDD implementation plan, you decompose complex software features into granular, 2-5 minute actionable steps that mandate failing tests before implementation. This structured planning phase ensures developers map out file changes and commit points prior to writing code.

What is the best way to prevent scope creep and architectural drift during feature development?

The best way to prevent scope creep and architectural drift is to generate a comprehensive, test-driven implementation plan before coding. This forces a rigorous planning phase that maps out file changes, test requirements, and specific documentation standards for agentic execution.

How does test-driven development task decomposition work for agentic execution?

Test-driven development task decomposition works by breaking complex features into bite-sized, actionable steps that require creating failing tests first. This granular task tracking enforces TDD principles and specific documentation standards necessary for agentic execution.

Can I use this planning approach for any software architecture or development task?

You can use this planning approach for complex feature development requiring architectural decomposition. It is specifically designed for software development tasks that need rigorous test-driven planning and granular task tracking to prevent disorganized or incomplete development.

Why should I create an implementation plan before writing any code?

You should create an implementation plan before writing code to solve the problem of disorganized development. Forcing a rigorous, test-driven planning phase ensures you have clear, bite-sized tasks and predefined commit points, which prevents scope creep and architectural drift.

Does writing-plans require any specific dependencies or components to function?

Writing-plans requires no external dependencies or components to function. It relies solely on your software requirements to generate a comprehensive, test-driven implementation plan mapped out with file changes and test requirements.