writing-plans

Generate test-driven implementation plans with task decomposition and file-level mapping.

1|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/LazyNinja435/astrai --skill writing-plans-lazyninja435
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/LazyNinja435/astrai/tree/main/.ai/skills/dev/writing-plans
Command: npx skills add https://github.com/LazyNinja435/astrai --skill writing-plans-lazyninja435

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of vague or unorganized development tasks by forcing a structured, test-driven approach that ensures every step is actionable and verifiable.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into bite-sized, 2-5 minute tasks with clear boundaries.
  • TDD Enforcement: Mandates writing failing tests before implementation to ensure code quality and reliability.
  • Use Case: When starting a new feature, use this skill to generate a comprehensive plan that maps out file changes, test cases, and commit points, ensuring the implementation is predictable and error-free.

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 a complex software feature?

To generate a TDD-ready implementation plan, you need to break complex software features into bite-sized 2-5 minute tasks with clear boundaries. This approach maps out file changes, test cases, and commit points to ensure predictable, error-free execution.

What is the best way to decompose complex development tasks into actionable steps?

Task decomposition breaks complex coding projects into verifiable, step-by-step execution units. This eliminates ambiguous placeholders in technical documentation by enforcing clear task boundaries and mapping file-level changes before implementation begins.

When do I need to use test-driven development planning for my coding projects?

You need test-driven development planning when starting new features that require clear task decomposition and verifiable execution. It mandates writing failing tests before implementation to ensure code quality, reliability, and frequent commits.

How does writing failing tests before implementation improve software quality?

Writing failing tests before implementation enforces a structured, test-driven approach that makes every step verifiable. This eliminates vague development tasks and ensures code quality by mapping out specific test cases and commit points upfront.

Can I use this task decomposition approach for large software engineering projects?

Yes, this task decomposition approach applies to complex coding projects requiring clear boundaries. It handles large software engineering projects by breaking them down into 2-5 minute tasks with file-level mapping and verifiable step-by-step execution.

Why should I map out file changes and commit points before coding a new feature?

Mapping file changes and commit points before coding ensures implementation is predictable and error-free. It eliminates vague development tasks by forcing a structured approach that satisfies requirements for frequent commits and verifiable step-by-step execution.