planner

Creates executable phase plans with task breakdown, dependency graphs, and goal-backward verification.

1|Updated Sep 3, 2026
One-click install
npx skills add https://github.com/amanpal3/SKILLs --skill planner-amanpal3
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: planner
Source: https://github.com/amanpal3/SKILLs/tree/main/.agent/plugins/gsd/.agents/skills/planner
Command: npx skills add https://github.com/amanpal3/SKILLs --skill planner-amanpal3

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a phase goal into concrete, executable work is hard: tasks end up vague, dependencies are unclear, and AI agents lose quality when plans are too large. This Skill produces structured PLAN.md files with specific tasks, verification criteria, and wave-based dependency ordering so execution stays focused and measurable. ## Core Features & Use Cases - Task Decomposition: Breaks phases into plans of 2-3 tasks each, with exact file paths, specific actions, executable verification commands, and measurable done criteria. - Dependency & Wave Planning: Builds dependency graphs, assigns execution waves, and enforces file-ownership rules so parallel plans never modify the same files. - Goal-Backward Verification: Derives must-have truths and artifacts from the desired end state, plus gap-closure plans when verification finds issues. - Use Case: After defining a user authentication phase, use this Skill to generate PLAN.md files covering registration, login, and session handling, each with curl-based verification steps and JWT acceptance criteria. ## Quick Start Ask the planner to create an executable phase plan for the user authentication phase with task breakdown and dependency waves.

Frequently Asked Questions about planner

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

FAQPage Schema
How do I create an executable phase plan for AI coding agents?▼

Define the phase goal, then decompose it into plans of 2-3 tasks each. Every task needs exact file paths, specific actions with pitfalls to avoid, an executable verify command, and measurable done criteria. Group independent plans into the same execution wave.

What is goal-backward planning in software projects?▼

Goal-backward planning starts from the done state and asks what must be true for the goal to be achieved, rather than listing tasks forward. It produces must-have truths and artifacts that every task must satisfy, ensuring plans stay aligned with the actual objective.

How many tasks should a single plan contain?▼

Each plan should contain 2-3 tasks maximum. Plans exceeding 3 tasks, touching more than 5 files per task, or crossing multiple subsystems should be split into separate plans to keep AI execution quality high and context usage under roughly 50 percent.

Can parallel plans modify the same files?▼

No. Plans assigned to the same execution wave must not modify the same files. If two plans need the same file, move one to a later wave or split the file into separate modules to avoid conflicts during parallel execution.

When should I use TDD plans instead of standard plans?▼

Use TDD plans for complex business logic with edge cases, financial calculations, state machines, data transformation pipelines, and input validation rules. A TDD plan follows Red, Green, Refactor phases where failing tests are written before implementation.

What are the limitations of large monolithic plans?▼

Large plans push AI context usage past 50-70 percent, where output quality degrades into rushed, minimal work. Aggressive atomicity with more plans of smaller scope keeps each execution within peak quality range and makes verification tractable.