writing-plans

Create atomic implementation plans with dependency graphs from design discussions.

Updated Mar 17, 2026
One-click install
npx skills add https://github.com/steven-3/supermind --skill writing-plans-steven-3
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/steven-3/supermind/tree/main/skills/writing-plans
Command: npx skills add https://github.com/steven-3/supermind --skill writing-plans-steven-3

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents execution failures caused by vague requirements by turning a design discussion into granular, atomic, dependency-ordered implementation plans that an executor can complete with fresh context.

Core Features & Use Cases

  • Atomic implementation plans with dependency graphs: Breaks work into self-contained tasks so parallel executors can safely work in “waves.”
  • Explicit file-level guidance: Specifies exact files to read, modify/create, and why, reducing guesswork and context loss.
  • Verification-first task specs: Forces each task to include acceptance criteria and a concrete command to verify correctness.
  • Planning pipeline support: Reads the design from the brainstorming output (when available) and saves plans/tasks to the phase directory structure for orchestrator execution.
  • Methodology injection by task type: Aligns tasks with appropriate approaches (e.g., TDD for feature/test tasks; REPRODUCE-ISOLATE-FIX-VERIFY for bug fixes).

Quick Start

Use the orchestrator Plan phase so writing-plans generates implementation tasks and saves them under the appropriate phase planning directories.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a software design into atomic implementation tasks for parallel execution?▼

Implementation planning breaks designs into self-contained, dependency-ordered tasks that parallel executors can safely complete in waves. Each task specifies exact files to read or modify, ensuring reliable execution with fresh context.

How do I create implementation plans with dependency graphs from design discussions?▼

Implementation planning generates task graphs by reading design discussions and outputting per-task specs with dependencies, acceptance criteria, and verification commands. This prevents execution failures caused by vague requirements and context loss between executors.

What's the best way to plan a bug fix using reproduce-isolate-fix-verify methodology?▼

Implementation planning injects methodology by task type, aligning bug fixes with the REPRODUCE-ISOLATE-FIX-VERIFY approach. It creates granular tasks with concrete verification steps, ensuring each fix is isolated, testable, and verifiable within a fresh context window.

How do I write testable task graphs for TDD feature implementation?▼

Implementation planning aligns feature and test tasks with Test-Driven Development methodology. It decomposes work into 2-5 minute atomic tasks, each with explicit acceptance criteria and verification commands, enforcing no-placeholder rules for reliable TDD execution.

Does this implementation planning approach work for refactoring existing codebases?▼

Implementation planning applies to product changes, bug fixes, refactors, and test writing. It specifies exact file-level instructions and dependency ordering, allowing executors to safely refactor code with fresh context while maintaining verification integrity.

Why do my orchestration execution tasks fail due to vague requirements?▼

Orchestration execution fails when tasks lack explicit file-level guidance and verification steps. Implementation planning prevents this by enforcing no-placeholder rules, dependency graphs, and per-task acceptance criteria, ensuring each executor completes work in 2-5 minutes reliably.