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.