writing-plans

Generate task-oriented implementation plans with files, tests, docs, and commits from specs.

Updated Feb 9, 2026
One-click install
npx skills add https://github.com/tridigitals/ispmanagement --skill writing-plans-tridigitals
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/tridigitals/ispmanagement/tree/main/.roo/skills/writing-plans
Command: npx skills add https://github.com/tridigitals/ispmanagement --skill writing-plans-tridigitals

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Use when you have a spec or requirements for a multi-step task, before touching code. This Skill helps engineers translate vague or high-level requirements into concrete, actionable implementation plans that specify which files to touch, what tests to write, what docs to update, and how to commit changes.

Core Features & Use Cases

  • Structured planning: map tasks to files, tests, docs, and commits.
  • Scope awareness: split plans at subsystem boundaries when needed to keep plans focused.
  • Iterative refinement: support incremental plan evolution with frequent commits.

Quick Start

Draft a plan that breaks a feature into tasks, files touched, tests, and documentation.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn project specs into an implementation plan?

To turn project specs into an implementation plan, you map high-level requirements into task-oriented steps that specify required files, tests, docs, and commits. This structured planning approach breaks vague requirements into concrete, actionable development tasks.

What is task decomposition for multi-step development tasks?

Task decomposition for multi-step development tasks is the process of breaking down feature requirements into focused, actionable items. It maps each task to specific file touchpoints, testing steps, documentation updates, and git commits to ensure a reproducible execution flow.

How do I plan code changes across multiple subsystem boundaries?

To plan code changes across multiple subsystem boundaries, you split the implementation plan at the subsystem level to keep tasks focused. This scope awareness ensures each plan remains manageable and targets the correct files and tests within that specific subsystem.

Do I need a complete spec before generating an implementation plan?

Yes, you need a spec or requirements document for a multi-step task before touching code. The planning process translates these high-level requirements into concrete file touchpoints and testing steps, supporting iterative refinement through frequent commits.

What is the best way to structure development plans for iterative refinement?

The best way to structure development plans for iterative refinement is to enforce a plan structure with explicit file touchpoints, testing steps, and frequent git commits. This supports incremental plan evolution as requirements change during the development process.