writing-plans

Generate structured, test-driven implementation plans with file-level task mapping.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill solves the problem of poorly defined or ambiguous development tasks by enforcing a rigorous, test-driven planning process that ensures every feature is broken down into actionable, verifiable steps.

Core Features & Use Cases

  • Task Decomposition: Automatically maps out file modifications and creation requirements based on project specs.
  • TDD Enforcement: Mandates a red-green-refactor workflow for every task, ensuring code quality and reliability.
  • Use Case: When starting a new feature, use this skill to generate a comprehensive implementation plan that includes specific file paths, test cases, and commit steps, preventing scope creep and architectural drift.

Quick Start

Use the writing-plans skill to generate a detailed implementation plan for the new user authentication module 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 features?

To create a test-driven development plan, decompose complex features into granular file-level tasks mapped to specific test cases. Enforcing a red-green-refactor workflow ensures every architectural boundary is verifiable and prevents scope creep.

What is the best way to break down software architecture requirements into actionable tasks?

Breaking down software architecture requirements involves mapping out explicit file modifications and creation requirements from project specs. This decomposition establishes clear architectural boundaries and yields actionable, verifiable development steps.

How does TDD enforcement work within an implementation plan?

TDD enforcement within an implementation plan mandates a strict red-green-refactor workflow for every decomposed task. This mechanism ensures code quality by requiring specific test cases to pass before progressing to subsequent file-level modifications.

Can I use this to plan refactoring workflows with clear file-level task mapping?

Yes, you can use this to plan refactoring workflows by generating explicit file-level task mapping. It decomposes refactoring efforts into verifiable steps, ensuring DRY principles and preventing architectural drift during code modifications.

When do I need a structured implementation plan for software development?

You need a structured implementation plan when starting complex feature development that requires clear architectural boundaries. It prevents ambiguous development tasks by ensuring every feature is broken down into actionable, verifiable steps before coding begins.

Why does my development workflow suffer from scope creep and architectural drift?

Your development workflow suffers from scope creep and architectural drift due to poorly defined or ambiguous development tasks. Generating a rigorous, test-driven implementation plan with explicit file paths and commit steps prevents this issue.