planner · jdrhyne — Claude Code skill: what it does, how to install
planner structures complex projects into sprints and atomic tasks with acceptance criteria, preparing ready-to-run plans for subagents.
MIT ★ 239 updated 2026-08-30
npx skills add jdrhyne/agent-skills --skill planner -a claude-codeWhat planner does
The skill guides project planning through five sequential phases: clarifying requirements with up to five targeted questions, inspecting the codebase, assembling detailed sprints, running a subagent review, and formatting the output. Each generated task includes exact file paths, estimated complexity on a 1–10 scale, testable acceptance criteria, and rollback instructions.
Every sprint is designed to produce a runnable increment with its own demo checklist. The resulting Markdown format is structured directly for downstream execution by workers like parallel-task or task-orchestrator.
The skill strictly separates planning from code edits: it does not touch implementation files and will not write the plan to disk unless an output artifact is requested.
What it helps with
- break down complex features into runnable sprints with explicit checklists
- generate orchestrator-ready Markdown plans for parallel execution
- map out file paths, dependencies, and validation steps for atomic commits
- define testing strategies, potential failure risks, and rollback steps before coding
Example prompts for the agent
- Create a detailed plan to refactor the billing service and save it to plan.md
- Break down adding OAuth login into atomic tasks with exact file locations
- Plan the database migration into sequential sprints ready for parallel workers
How to install planner
1Skills CLI (Vercel)
npx skills add jdrhyne/agent-skills --skill planner -a claude-code2Manually: put the files in place
~/.claude/skills/planner/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/planner/
1Skills CLI (Vercel)
npx skills add jdrhyne/agent-skills --skill planner -a codex2Manually: put the files in place
.agents/skills/planner/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add jdrhyne/agent-skills --skill planner -a cursor2Manually: put the files in place
.cursor/skills/planner/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install jdrhyne/agent-skills skills/planner2Manually: put the files in place
.github/skills/planner/SKILL.md1Skills CLI (Vercel)
npx skills add jdrhyne/agent-skills --skill planner -a gemini-cli2Platform CLI
gemini skills install https://github.com/jdrhyne/agent-skills --path skills/plannerManually: put the files in place
.devin/skills/planner/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about planner
How to install planner in Claude Code?
Run npx skills add jdrhyne/agent-skills --skill planner -a claude-code in your terminal.
What does the planner skill do?
It researches the codebase, clarifies constraints, and generates an actionable sprint-based plan formatted for autonomous subagents.
Will planner automatically start implementing tasks?
No, safety constraints keep the skill focused purely on planning until you explicitly ask to proceed with execution.
Source text
SKILL.md · MIT
---
name: planner
description: Create structured plans for multi-task projects that can be used by the task-orchestrator skill. Use when breaking down complex work into parallel and sequential tasks with dependencies.
metadata: {"clawdbot":{"emoji":"📋"}}
permissions:
- file_write: "May save the completed plan to a file when the user asks for a persisted artifact."
---
# Planner
Create structured, orchestrator-ready plans for multi-task projects.
**Source**: Adapted from am-will's codex-skills workflow patterns
**Pairs with**: task-orchestrator skill for follow-on implementation
---
## Quick Start
Follow this process:
1. **Phase 0**: Clarify requirements (ask up to 5 targeted questions)
2. **Phase 1**: Research & understand the codebase
3. **Phase 2**: Create detailed plan with sprints, tasks, acceptance criteria
4. **Phase 3**: Subagent review of the plan
5. **Phase 4**: Return the plan in markdown and save a file only if the user asked for a persisted artifact
---
## Key Principles
### Task Atomicity
Each task must be:
- **Atomic and committable** — small, independent pieces of work
- **Specific and actionable** — not vague
- **Testable** — include tests or validation method
- **Located** — include file paths and code locations
### Bad vs Good Task Breakdown
❌ Bad: "Implement third-party sign-in"
✓ Good:
- "Add sign-in config to environment variables"
- "Install and configure the required authentication package"
- "Create sign-in callback route handler in src/routes/auth.ts"
- "Add the sign-in button to the login UI"
### Sprint Structure
Each sprint must:
- Result in a **demoable, runnable, testable** increment
- Build on prior sprint work
- Include clear demo/verification checklist
---
## Plan Template
```markdown
# Plan: [Task Name]
**Generated**: [Date]
**Estimated Complexity**: [Low/Medium/High]
## Overview
[Brief summary of what needs to be done and the general approach]
## Prerequisites
- [Dependencies or requirements that must be met first]
- [Tools, libraries, or access needed]
- [Tooling limitations, e.g., browser relay/CDP restrictions]
## Sprint 1: [Sprint Name]
**Goal**: [What this sprint accomplishes]
**Demo/Validation**:
- [How to run/demo this sprint's output]
- [What to verify]
### Task 1.1: [Task Name]
- **Location**: [File paths or components involved]
- **Description**: [What needs to be done]
- **Perceived Complexity**: [1-10]
- **Dependencies**: [Any previous tasks this depends on]
- **Acceptance Criteria**:
- [Specific, testable criteria]
- **Validation**:
- [Test(s) or alternate validation steps]
### Task 1.2: [Task Name]
[...]
## Sprint 2: [Sprint Name]
[...]
## Testing Strategy
- [How to test the implementation]
- [What to verify at each sprint]
## Potential Risks
- [Things that could go wrong]
- [Mitigation strategies]
## Rollback Plan
- [How to undo changes if needed]
```
---
## Hand-off
Once plan is ready, hand off to the **parallel-task worker**:
```
Please run parallel-task.md against my-plan.md
```
Or invoke directly:
> "Run all unblocked tasks in plan.md using parallel subagents. Keep looping until all tasks are complete."
## Safety Boundaries
- Do not save a plan file unless the user asked for one or the surrounding workflow explicitly needs a persisted artifact.
- Do not assign overlapping write scopes to parallel tasks without calling out the conflict.
- Do not invent dependencies, validation steps, or completion status that the repo context does not support.
- Do not turn a planning request into implementation work unless the user explicitly asks to move from planning to implementation.
---
## Related
- [`parallel-task`](../parallel-task/) — Parallel task worker that executes the plan this skill produces
Adapted from am-will's codex-skills planner/parallel-task prompts.
© jdrhyne · MIT · jdrhyne/agent-skills
Similar skills
All skills for Agent setup: memory, context, orchestration →planner by other authors comes first.