make-plan
π―SkillHelps your AI agent write a step-by-step plan before building a feature. It first checks the real documentation for what is available, then splits the work into phases. Each phase has a clear goal, examples to copy, checks to prove it works, and mistakes to avoid.
Installation
npx skills add thedotmack/claude-mem --skill make-planRun it in a terminal; it asks which AI coding tools to install it for (Claude Code, Codex, Cursor and more).
Uses skills.sh Β· Node.js 22.20+
After installing
Ask for related work and the agent uses it on its own, or call it yourself.
/make-planInstall by hand
Copy the whole skill folder from GitHub to the place below. Copying only SKILL.md can leave out files the skill uses.
Open the skill folder β- This project
.claude/skills/make-plan/ - All projects
~/.claude/skills/make-plan/
These paths are for Claude Code. For other tools, the command above puts it in the right place.
SKILL.md
View on GitHub βCreate a detailed, phased implementation plan with documentation discovery. Use when asked to plan a feature, task, or multi-step implementation β especially before executing with do.
Make Plan
You are an ORCHESTRATOR. Create an LLM-friendly plan in phases that can be executed consecutively in new chat contexts.
Delegation Model
Use subagents for fact gathering and extraction (docs, examples, signatures, grep results). Keep synthesis and plan authoring with the orchestrator (phase boundaries, task framing, final wording). If a subagent report is incomplete or lacks evidence, re-check with targeted reads/greps before finalizing.
Subagent Reporting Contract (MANDATORY)
Each subagent response must include:
- Sources consulted (files/URLs) and what was read
- Concrete findings (exact API names/signatures; exact file paths/locations)
- Copy-ready snippet locations (example files/sections to copy)
- "Confidence" note + known gaps (what might still be missing)
Reject and redeploy the subagent if it reports conclusions without sources.
Plan Structure
Primary Goal (top of the document, before Phase 0)
Every plan opens with a Primary goal section: one or two sentences describing the user-visible outcome the plan exists to produce β not the mechanism. Write it so a reader with no context knows what "done" looks like.
- Good: "A paying user whose observer stops working finds out within one session and is told the one thing to do about it."
- Bad: "Add a 6-code error taxonomy to the gateway."
Then, directly under every phase title (Phase 0 through the final verification phase), add a short paragraph:
How this serves the primary goal: β¦
If you cannot write that paragraph honestly for a phase, the phase does not belong in the plan. This is the scope test.
Phase 0: Documentation Discovery (ALWAYS FIRST)
Before planning implementation, deploy "Documentation Discovery" subagents to:
- Search for and read relevant documentation, examples, and existing patterns
- Identify the actual APIs, methods, and signatures available (not assumed)
- Create a brief "Allowed APIs" list citing specific documentation sources
- Note any anti-patterns to avoid (methods that DON'T exist, deprecated parameters)
The orchestrator consolidates findings into a single Phase 0 output.
Each Implementation Phase Must Include
- What to implement β Frame tasks to COPY from docs, not transform existing code
- Good: "Copy the V2 session pattern from docs/examples.ts:45-60"
- Bad: "Migrate the existing code to V2"
- Documentation references β Cite specific files/lines for patterns to follow
- Verification checklist β How to prove this phase worked (tests, grep checks)
- Anti-pattern guards β What NOT to do (invented APIs, undocumented params)
Final Phase: Verification
- Verify all implementations match documentation
- Check for anti-patterns (grep for known bad patterns)
- Run tests to confirm functionality
Presenting the Plan to the User
After writing the plan file, present it in chat using this exact format β and only this format. Length is the five fixed sections plus exactly one line per phase in Steps, so a plan with any number of phases fits. Emojis are the section markers. One line per step. Define jargon in the line where it first appears; assume the reader has none of the conversation's context.
## π― Goal
<the primary goal, one sentence>
## 𧨠Now
<what's broken / the current state, one sentence>
## π§ Idea
<the design in one sentence>
## π οΈ Steps
- 1οΈβ£ **<phase name>** β <what it does, one line>
- 2οΈβ£ **<phase name>** β β¦
- NοΈβ£ **Verify** β <how we prove it worked>
## π« Not now
<explicit deferrals, one line, separated by Β·>
Do not add sections. Do not add sub-bullets. Do not restate file paths or line numbers here β those live in the plan file. If the user wants detail, they will open the file or ask.
Key Principles
- Documentation Availability β Usage: Explicitly require reading docs
- Task Framing Matters: Direct agents to docs, not just outcomes
- Verify > Assume: Require proof, not assumptions about APIs
- Session Boundaries: Each phase should be self-contained with its own doc references
Anti-Patterns to Prevent
- Inventing API methods that "should" exist
- Adding parameters not in documentation
- Skipping verification steps
- Assuming structure without checking examples
See Also
oh-my-issuesβ the issue-side sibling. When the plan you're being asked to make is rooted in a bug or feature backlog rather than a fresh idea, route throughoh-my-issuesfirst to cluster issues by root cause into plan masters andplans/0X-*.mddesign docs.make-planthen operates on the design doc for one plan slice.
More from this repository10
Claude-Mem gives Claude Code a memory that stays after a session ends. It keeps that memory in a compressed, shorter form.
claude-mem gives Claude Code a memory that lasts between sessions. It records what Claude does while you work, saves short summaries, and shows that context automatically when you start a new session.
Searches your saved Claude-Mem memory on cmem.ai to recall what happened in earlier sessions. It answers questions like what you did last time on a project, file or decision.
Lets your AI agent explore a codebase by looking at its outline first, such as function and class names, instead of reading whole files. This saves the agent's reading budget. It uses three companion tools to search code, show a file's structure, and open only the part you need.
Carries out a step-by-step plan by handing each piece of work to separate helper agents. After each step it checks the result, reviews the code and saves the changes to git only when the checks pass.
Writes a story-style report of a project's whole development history, based on the notes that claude-mem has saved over time. It needs the claude-mem background service to be running.
Automated semantic versioning and release workflow for Claude Code plugins, bumps package.json, marketplace.json, and plugin.json in lockstep, runs the build, tags the commit, creates a GitHub release, and generates changelog entries. Enforces 'nothing left uncommitted or unpushed' by running git status at the end.
Turns the notes claude-mem keeps about your past work into focused knowledge bases you can chat with. You pick notes by project, topic, file, or date, load them into a session, then ask questions about past decisions and fixes.
Reviews a design against Dieter Rams' ten principles of good design, scoring each one with evidence. It then recommends a new design, a refinement or a redesign, and writes a ready-to-use prompt for /make-plan.
Tells your AI to read every source file in your project in full before starting work, so it deeply understands the code. It uses a lot of tokens up front to save effort later.