writing-plans

Generate implementation plans with TDD steps, file paths, and test commands.

34|6|Updated Jan 19, 2026
One-click install
npx skills add https://github.com/Chikage0o0/opencode --skill writing-plans-chikage0o0
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Chikage0o0/opencode/tree/main/skills/writing-plans
Command: npx skills add https://github.com/Chikage0o0/opencode --skill writing-plans-chikage0o0

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the chaos of tackling multi-step development tasks without a clear roadmap, preventing errors, scope creep, and wasted time by providing structured, detailed plans for engineers unfamiliar with the codebase.

Core Features & Use Cases

  • Comprehensive Task Breakdown: Creates bite-sized, TDD-focused steps with exact code, tests, and commands for each task.
  • File Structure Mapping: Outlines precise file changes, responsibilities, and interfaces before implementation begins.
  • Self-Review and Handoff: Includes built-in checks for completeness and offers subagent or inline execution options.
  • Use Case: For a new feature spec involving database migrations and UI updates, it generates a plan with failing tests first, minimal implementations, and frequent commits, ensuring verifiable progress.

Quick Start

Provide your project spec to the writing-plans skill to receive a detailed implementation roadmap with step-by-step tasks.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I decompose a complex software feature into executable implementation plans?

To decompose a complex software feature into an executable implementation plan, provide your project specification to generate a detailed roadmap with exact file paths, complete code snippets, test commands, and Git commit steps. This roadmap prevents scope creep by mapping out precise file changes and responsibilities before development begins.

How do I plan a multi-step development task using TDD practices?

Planning a multi-step development task using TDD practices involves creating bite-sized steps that prioritize failing tests, minimal implementations, and frequent commits. This approach ensures verifiable progress by generating a comprehensive task breakdown that outlines exact code, tests, and commands for each step before execution.

What is task decomposition for multi-step development tasks across subsystems?

Task decomposition for multi-step development tasks is the process of breaking down complex feature specifications involving multiple subsystems into structured, bite-sized implementation steps. It generates a comprehensive plan satisfying requirements for exact file paths, complete code snippets, test commands, and self-reviews to ensure structured execution.

Can I hand off a generated implementation plan to a subagent for execution?

Yes, you can hand off a generated implementation plan to a subagent for execution, as the plan includes built-in checks for completeness and offers subagent or inline execution options. This allows engineers unfamiliar with the codebase to execute the detailed roadmap with verifiable progress automatically.

Does this implementation planning approach work with Git workflows and database migrations?

Yes, this implementation planning approach works with Git workflows and database migrations by generating plans that feature frequent commits and step-by-step task execution. It applies to codebases requiring task decomposition and Git workflows for features across subsystems, including database migrations and UI updates.

What is the best way to avoid scope creep when tackling multi-step development tasks?

The best way to avoid scope creep when tackling multi-step development tasks is to generate a comprehensive implementation plan with structured, detailed steps before coding begins. This roadmap provides bite-sized, TDD-focused steps with exact file changes and responsibilities, preventing errors and wasted time for engineers unfamiliar with the codebase.