Claude Code's auto-memory can collect notes you never sat down to write: a correction you made, a preference you explained, a pointer to something useful in another project. Those notes help the next session. Whether they will follow you to another tool or computer is a different question.
For work that will matter next month, I want a record I can inspect, revise and hand to the next contributor. A convenient memory feature should not quietly become the only place a project knows why it made a decision.
Three questions before relying on tool memory
Is it portable across tools? When you use a second assistant, can it find and read the same decision, including the conditions that made it sensible?
Is it synced across machines? When you move from a laptop to a desktop, does the record follow the work, or does each machine maintain a different account?
Is it version-controlled? If a session changes a note incorrectly, can you inspect the change and recover the previous version?
These questions apply to the work you need to preserve. They do not require every product's memory feature to have the same design. Conversation history, account preferences, local notes and project instructions have different storage and access rules.
What I found on my own machine
I had already written about durable project memory. In July, I checked what was sitting outside that system in my own Claude Code setup.
The first memory directory contained seventeen files. After that first pass, I expanded the search and found eighteen more files in five other directories: thirty-five files across six directories, all stored only on that computer. The first directory was not in a Git repository. Finding and dealing with it had not dealt with the other five.
Some notes held useful material that needed a durable home. Others were duplicates, or had become forwarding addresses: short files pointing to rules and lessons already maintained in the project system. An earlier working session had already begun routing new learnings into that Git-tracked system and leaving pointers behind. I had not asked it to make that change. The improvised workaround was a sign to me that the tool's convenient memory did not meet my need for a durable project record.
I wanted that arrangement to be deliberate and consistent. A project decision should have one maintained record, with an entry path the tools I use can follow. Keeping another unsynchronized copy of the same decision gives me another place to correct whenever the decision changes.
Put the durable record with the work
My preferred structure uses plain files in a Git repository: current working state, stable reference material, dated session records and lessons that apply across projects. Each record has a job. The working-state file tells the next contributor where to begin; the reference and history preserve the reasons that should survive a session ending.
That is the durable-memory part of synthesis project management, within the broader synthesis engineering discipline. The cross-tool workflow, tiered context structure and decision framework develop different parts of that approach.
Plain text gives an authorized assistant something it can read without depending on the memory implementation of one vendor. The project still needs instructions that lead to the right files. History and synchronization also need an operating process, which the handoff check below makes explicit.
Once that durable record exists, a second, drifting account of its facts is a liability. A tool's preference notes or a pointer to the canonical record can have a separate purpose. They should not become a competing authority for project decisions.
Know which memory feature you are using
Claude Code's current documentation, checked October 1, 2026, describes readable Markdown notes accumulated across sessions. By default, worktrees and subdirectories of the same Git repository share a local memory directory; those files are not shared across machines or cloud environments. The autoMemoryDirectory setting can change the location. The memory index loads at startup within documented limits; topic files are read when needed. A saved file is not proof that a particular session read it.
OpenAI's memory documentation distinguishes local Codex memory from the account and workspace memory used by ChatGPT web and ChatGPT Work. It recommends keeping required team guidance in project instructions or checked-in documentation.
Follow one decision through the handoff
Choose a project decision that already has a record you can inspect. For an illustrative test, suppose the record says an uploaded file becomes eligible for processing only after the upload is marked complete. The condition matters: losing it changes the behavior someone might implement next.
Start by locating the record yourself. Note its date or version, where it lives, who can access it and which assistant is expected to read it. If all you have is an assistant's paraphrase, trace that paraphrase to the underlying decision before using it as the expected answer.
Open a fresh session with the project's normal entry instructions. Ask it to find the decision and explain the condition. Have it identify the source it used. Do not supply the answer in the question; that would test whether the assistant can repeat your prompt.
Compare its response with the record. Several outcomes need different repairs:
- If the record is missing from the environment, inspect the transfer or synchronization process.
- If the record is present but unreadable, inspect permissions and the assistant's available tools.
- If the assistant can read it but does not find it, inspect the project's entry instructions and links.
- If it finds the right version but changes the meaning, correct the interpretation and check whether the source itself is ambiguous.
Repeat the test in the other environment you intend to use: a second client, another authorized computer or a colleague's project checkout. Check the version there as well as the words in the answer. A successful handoff on one machine does not establish that a second machine has received the same files.
Git can provide version history and a way to exchange changes. It still needs a working process for committing the intended records, transferring them, updating the destination and resolving conflicts. An uncommitted decision on a laptop has not traveled merely because its folder belongs to a repository.
Keep the procedure proportionate to the work
A quick script or a one-off debugging session may need only its current conversation and files. Work you will return to next quarter, or hand to someone else, deserves a durable record. The three questions help you choose; they need not turn a focused task into an elaborate multi-tool process.
Update — October 5, 2026: I changed my policy on October 1. The guidance below replaces my earlier advice about disabling or redirecting native memory.
I keep native memory enabled in Claude Code, Codex and Muse Code. I treat its notes as a capture buffer: material to review for the durable record, rather than an authority that can overrule it. When a native note conflicts with the maintained synthesis project record, the project record wins.
During a routine checkpoint or end-of-day review, use each client's own tools to inspect its new memory entries. Separate duplicates from useful material that has no durable home, check the source, and carry useful entries into the appropriate project, reference or lesson record under the right access controls. Verify the destination and retain the source.
Do not delete the raw memory files or turn memory off to resolve a conflict. Reconcile the conflicting note with the maintained record. Where a client's review or export path has not been verified, leave that work explicitly pending. A successful copy alone does not establish that the next session will find and use it; repeat the handoff check.
Your work should keep what it has learned when you change tools or machines. That record belongs with the project, under your control.