writing-plans

Convert a spec into an executable implementation plan with tasks and tests.

Updated Mar 7, 2026
One-click install
npx skills add https://github.com/randoneering/nix-flake-mirror --skill writing-plans-randoneering
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/randoneering/nix-flake-mirror/tree/main/home/programs/opencode/skills/writing-plans
Command: npx skills add https://github.com/randoneering/nix-flake-mirror --skill writing-plans-randoneering

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Converts a spec or requirements into a concrete, executable implementation plan, reducing guesswork and rework during software development.

Core Features & Use Cases

  • Task decomposition: breaks a feature into concrete tasks, owners, and an execution order.
  • Change footprint & testing plan: identifies which files to modify, new tests to add, and validation steps.
  • Documentation & commits: outlines documentation needs and suggested commit history.

Quick Start

Provide a feature brief or spec and I will generate a complete implementation plan.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn a software spec into an actionable implementation plan?

To turn a software spec into an actionable implementation plan, provide the feature brief to generate a document detailing concrete task breakdowns, execution order, touched files, tests, and commit steps.

How do I break down a multi-step software feature for development?

Break down a multi-step software feature by decomposing the spec into concrete tasks, assigning owners, defining an execution order, and outlining required testing considerations and validation steps.

What is the best way to plan code changes and tests before implementation?

The best way to plan code changes and tests is generating a change footprint that identifies which files to modify, new tests to add, and validation steps to execute before actual coding begins.

Does this implementation planning approach work for complex multi-step tasks?

This implementation planning approach works specifically for multi-step software tasks requiring upfront design, applying task breakdown and testing considerations to reduce guesswork and rework during development.

Can I outline commit history and documentation needs during task breakdown?

You can outline documentation needs and suggested commit history during task breakdown, ensuring the generated implementation plan includes structured commit steps alongside the execution order.