Planning with Files
OthmanAdi/planning-with-filesKeeps task_plan.md, findings.md and progress.md on disk and re-injects them via hooks, so a plan survives /clear, compaction and crashes.
Recommended
Broad access Depth 4/5
What a Claude memory skill does
A Claude memory skill gives an agent a way to keep information across sessions. Some do it with a plain file, such as a handoff summary or a plan. Others capture every conversation turn through hooks and search it later. We reviewed 12: 4 get an install verdict and 8 come with caveats.
The two ends of the range are far apart. A handoff skill writes one summary file. A memory layer records your sessions, which is useful but means deciding what gets stored and where.
All of these skills address the same limit. A Claude Code session loses its working context when you run /clear, when the conversation is compacted, or when the session crashes or ends. Whatever the agent learned about your task has to be rebuilt the next time. A memory skill writes some of that context somewhere durable and puts it back in front of the agent later. The skills differ in how much they write, where they write it, and how automatically they do it.
Three kinds of memory system
The 12 skills in this category fall into three rough groups. Knowing which group a skill belongs to tells you most of what you need about its footprint.
Handoff and guidance skills. You invoke these yourself, and they produce one document or none at all. handoff compacts the current conversation into a portable summary. claude-handoff does the same and then launches a background Claude Code agent seeded with that summary. context-engineering writes nothing. It is a guide to choosing what goes into the context window.
File-based memory. These keep state as Markdown on your disk, usually inside your project or an Obsidian vault, and often use hooks to re-inject it. Planning with Files, obsidian-wiki and Obsidian Second Brain belong here. You can open every file in an editor.
Capture layers with an index. These record sessions or tool output through hooks and store it in a database or search index. Context Mode uses local SQLite. memsearch keeps Markdown files as the source of truth with a Milvus search index. Pro Workflow stores your corrections in SQLite. memU mines agent session logs into a shared Markdown wiki, locally or through memU Cloud. Continuous Claude is a larger personal infrastructure built on the same hook-driven idea.
Distilly sits slightly apart. It distills one person’s messages, documents and public material into a reusable Person Profile packaged as an agent skill, so the memory it produces is about a person, not a project.
What to look for in a Claude memory skill
Look at the capture method. A skill that you invoke by hand is easy to reason about. One that installs hooks fires on every prompt or tool call. For a memory plugin that is the core feature, not a side effect. Claude Code supports hooks in skills, as the skills docs list, so hook behavior is normal here, but you should know it exists.
Then look at storage. Plain Markdown in your project is easy to read and delete by hand. A vector index or SQLite database takes more effort to inspect, even when it is local. Cloud options change the picture, since your conversations then leave your machine. Check the embedding model too: a local model avoids sending text out but may be a large download.
Finally, check the clean-up path. Can you see what was stored, and can you delete it? Of the 12 skills, 3 are clean, 3 are marked “review” and 6 have broad access, the largest broad share of any category. Our security page explains the labels.
Recommended memory skills
- handoff is clean and tiny: 1.5 KB that writes a conversation summary to your temp folder so a fresh session can continue. The agent is told to redact secrets, but that is done by the model, so check the file. It has about 1.06 million recorded installs.
- context-engineering is a clean 15 KB guide to what to put in front of an agent and when: rules files, spec excerpts, source files, error output and handoffs. It adds guidance, not tooling.
- Planning with Files keeps
task_plan.md,findings.mdandprogress.mdon disk and re-injects them by hook, so a plan survives/clear, compaction and crashes. We mark it broad access: unrestricted Bash is pre-approved and hooks run on every prompt and tool call. - obsidian-wiki has 40 skills that build a linked Obsidian vault from your notes, code and past agent sessions, then answer questions with citations. State is plain Markdown on your disk. The CLI registers session hooks by default unless you pass
--no-hooks. - claude-handoff is clean too but starts a new background Claude Code session from the summary, running with whatever permissions you have granted. It has a caveats verdict for that reason.
For heavier systems, read the notes first. Context Mode routes large tool outputs into a local SQLite index through hooks, and it is source available under Elastic License 2.0, not an OSI license. memsearch captures every conversation turn through hooks and stores summaries locally by default, with a 558 MB local embedding model, though cloud embedding is an option you can choose.
The other memory skills we reviewed
The remaining caveats-verdict skills are larger and do more, which is why each needs a closer read before you install it.
- Context Mode is an MCP server plus hooks. It keeps bulky tool output out of the context window, indexes it in local SQLite, and restores session state after compaction. Security: broad.
- memsearch offers cross-agent persistent memory for Claude Code, Codex, OpenClaw, OpenCode and DeepSeek Harness. Markdown files are the source of truth and Milvus handles the search index, so recall works through embedding-based semantic search, not keyword matching alone. Security: broad.
- memU mines agent session logs into a shared Markdown wiki and re-injects it across Codex, Claude Code, Cursor and others. You can run it locally or use memU Cloud. Security: broad.
- Obsidian Second Brain is a persistent, self-rewriting memory in your Obsidian vault with 48 commands, a shared cross-agent logbook called Crew, scheduled maintenance and a research toolkit. Security: review.
- Pro Workflow is a Claude Code plugin with 41 skills and many hooks. It stores your corrections in SQLite and adds searchable research wikis, quality gates and cost tracking. Security: review.
- Continuous Claude is a personal Claude Code setup with about 160 skills, 32 agents and 30 hooks that inject skill hints, isolate subagent context to files, and fight compaction. Security: broad.
- Distilly builds a Person Profile from someone’s messages, documents and public material. Because it processes material about a real person, think about whose data you feed it. Security: broad.
How the 12 compare
| Skill | Where memory lives | How it is captured | Security |
|---|---|---|---|
| handoff | One summary file in your temp folder | You invoke it | Clean |
| claude-handoff | Summary file, plus a background session | You invoke it | Clean |
| context-engineering | Nothing stored; guidance only | You invoke it | Clean |
| Planning with Files | Three Markdown files on disk | Hooks on every prompt and tool call | Broad |
| obsidian-wiki | Markdown in an Obsidian vault | Session hooks by default | Review |
| Obsidian Second Brain | Obsidian vault and Crew logbook | Commands and scheduled maintenance | Review |
| Pro Workflow | SQLite | Hooks | Review |
| Context Mode | Local SQLite index | MCP server and hooks | Broad |
| memsearch | Markdown plus Milvus index | Hooks on every turn | Broad |
| memU | Markdown wiki, local or memU Cloud | Mined from session logs | Broad |
| Continuous Claude | Files for subagent context | 30 hooks | Broad |
| Distilly | A Person Profile skill | Built from supplied material | Broad |
How to choose and set one up
- Start with the smallest tool that covers your problem. If you mainly lose context when a long session ends, try handoff first. It is one file, and you can read the result before you use it.
- Move to file-based memory if you need a plan that persists. Planning with Files suits long tasks that get interrupted by
/clearor compaction. Before installing, accept that it pre-approves unrestricted Bash. - Choose a vault if you want a knowledge base, not a task log. obsidian-wiki and Obsidian Second Brain both write to Obsidian. If you want the vault without automatic session capture, obsidian-wiki’s
--no-hooksflag turns off the default hooks. - Pick a capture layer only when you need recall across many sessions or agents. memsearch and memU work across multiple agents. Plan for the storage: memsearch’s local embedding model is a 558 MB download, and memU Cloud or cloud embedding means your conversation text leaves your machine.
- Read the files after the first run. Open the handoff document, the plan files, or the vault notes and confirm nothing sensitive was written. For SQLite or index-backed tools, find out where the database lives before you rely on it.
Example workflow with handoff
A common pattern for context across sessions looks like this. Near the end of a long session, ask the agent to run the handoff skill, for example: “Write a handoff so a new session can pick this up.” The skill writes the summary to your temp folder. Open the file and check it for secrets, since the model handles redaction. Then start a fresh session and point the agent at that file. If you would rather the work continue straight away, claude-handoff starts the background session for you, but that session runs with whatever permissions you have already granted.
Who should skip a memory layer
Hook-based capture is a poor fit if you work in repositories with credentials, client data or anything you would not want written to a local database. It also adds behavior you cannot see on every prompt, which makes debugging harder when the agent acts oddly. If you only need to restart a session now and then, a handoff file does the job with far less to audit. If your organization requires OSI-licensed tools, note Context Mode’s Elastic License 2.0.
Best practices for agent memory
Keep one memory system active per project. Several skills that each inject context through hooks can all add text to the same prompt, and none of them can see what the others added. Keep memory files inside the project or vault so you can delete them with the project. Treat model-side redaction as a first pass, not a guarantee. For more on deciding what belongs in the context window, the context-engineering skill covers rules files, spec excerpts, source files, error output and handoffs.
Related categories
For planning and process skills, see planning, TDD and debugging. For notes apps, see productivity skills. The category page lists all 12, and how we review explains scoring.