From persistent-planning
Transforms workflow to use persistent markdown files for planning, progress tracking, and knowledge storage. Use when starting complex tasks, multi-step projects, research tasks, or when the user mentions planning, organizing work, tracking progress, or wants structured output.
npx claudepluginhub theglitchking/persistent-planningThis skill uses the workspace's default tool permissions.
Use persistent markdown files as your "working memory on disk" -- the context engineering pattern pioneered by Manus AI.
Integrates Mem0 persistent memory for Claude Code tasks using MCP tools. Retrieves relevant memories on new tasks, stores learnings like decisions and strategies, captures session states.
Creates web-based slidedecks for developers using Slidev with Markdown, Vue components, code highlighting, animations, interactive demos, and presenter notes. Use for technical presentations, conference talks, code walkthroughs, and workshops.
Use persistent markdown files as your "working memory on disk" -- the context engineering pattern pioneered by Manus AI.
Start planning in one command:
/start-planning "Your task name here"
This automatically:
.planning/ directory.planning/[task-slug]/task_plan.md with templates.planning/[task-slug]/notes.md with templatesExample:
/start-planning "Refactor authentication system"
If /start-planning isn't available:
.planning/[task-slug]/ directorytask_plan.md with goal and phases[x] and change statusUnlike in-memory task tracking (which disappears between sessions), your plans stay on disk and support multiple concurrent tasks.
Session 1:
/start-planning "Complex feature"
[Work, update plans]
Session 2 (next day):
Read .planning/complex-feature/task_plan.md <- Plans are still here
Read .planning/complex-feature/notes.md <- Notes are still here
[Continue work]
/start-planning "Refactor authentication"
-> Creates .planning/refactor-authentication/
/start-planning "Fix memory leak"
-> Creates .planning/fix-memory-leak/
Both plans coexist without overwriting each other.
Each task gets its own directory. No conflicts, no overwrites.
For every task, files are created in a task-specific directory:
| Location | Purpose | When to Update |
|---|---|---|
.planning/[task-name]/task_plan.md | Track phases and progress | After each phase |
.planning/[task-name]/notes.md | Store findings and research | During research |
[deliverable].md | Final output (root directory) | At completion |
Example structure:
.planning/
├── refactor-auth/
│ ├── task_plan.md
│ └── notes.md
├── fix-memory-leak/
│ ├── task_plan.md
│ └── notes.md
└── performance-optimization/
├── task_plan.md
└── notes.md
Loop 0: Run /start-planning "Task name" (creates task directory automatically)
Loop 1: Define phases in .planning/[task-name]/task_plan.md
Loop 2: Research -> save to .planning/[task-name]/notes.md -> update plan
Loop 3: Read notes -> create deliverable -> update plan
Loop 4: Deliver final output
Loop 5: Next task? Run /start-planning again (no conflicts)
Before each major action:
Read .planning/[task-name]/task_plan.md # Refresh goals in attention window
After each phase:
Edit .planning/[task-name]/task_plan.md # Mark [x], update status
When storing information:
Write .planning/[task-name]/notes.md # Don't stuff context, store in file
Task 1:
Read .planning/refactor-auth/task_plan.md
Edit .planning/refactor-auth/notes.md
Edit .planning/refactor-auth/task_plan.md
Task 2 (same session, no conflicts):
Read .planning/fix-memory-leak/task_plan.md
Edit .planning/fix-memory-leak/notes.md
Edit .planning/fix-memory-leak/task_plan.md
Both tasks coexist independently. Switch between them as needed.
Create this file FIRST for any complex task:
# Task Plan: [Brief Description]
## Goal
[One sentence describing the end state]
## Phases
- [ ] Phase 1: Plan and setup
- [ ] Phase 2: Research/gather information
- [ ] Phase 3: Execute/build
- [ ] Phase 4: Review and deliver
## Key Questions
1. [Question to answer]
2. [Question to answer]
## Decisions Made
- [Decision]: [Rationale]
## Errors Encountered
- [Error]: [Resolution]
## Status
**Currently in Phase X** - [What I'm doing now]
For research and findings:
# Notes: [Topic]
## Sources
### Source 1: [Name]
- URL: [link]
- Key points:
- [Finding]
- [Finding]
## Synthesized Findings
### [Category]
- [Finding]
- [Finding]
Create the .planning/ directory before starting any complex task. Then create task_plan.md. This is non-negotiable.
Before any major decision, read the plan file. This keeps goals in your attention window.
After completing any phase, immediately update the plan file:
[x]Large outputs go to files, not context. Keep only paths in working memory.
Every error goes in the "Errors Encountered" section. This builds knowledge for future tasks.
When a task is complete, delete the task directory:
rm -rf .planning/[task-name]/
Or clean up everything:
rm -rf .planning/
Use 3-file pattern for:
Skip for:
| Don't | Do Instead |
|---|---|
| Use volatile task tracking for persistence | Use /start-planning for on-disk persistence |
| Put planning files in root | Use .planning/[task-name]/ subdirectories |
| State goals once and forget | Re-read plan before each decision |
| Hide errors and retry | Log errors to plan file |
| Stuff everything in context | Store large content in files |
| Overwrite previous plans | Use /start-planning (auto-creates unique task dir) |
| Start executing immediately | Run /start-planning "task name" FIRST |
| Switch tasks without saving | Update task_plan.md before switching |
See reference.md for:
See examples.md for: