Work With Me About Offerings Podcast
About Contact
The Split Brain Problem: How Claude Builds Separate Memories · Nathaniel Solace
Tutorial · Critical Infrastructure

The Split Brain
Problem.

Claude Desktop and Claude Code silently build separate memory systems. You are probably training two assistants right now and don’t know it.

Nathaniel Solace · ThoughtLeaderAI
The Problem

Three apps.
Three brains.

Claude Desktop, Claude Code in the terminal, and the VS Code extension all store memory in different directories. They look the same. They feel the same. They are not the same. Every correction you give one interface is invisible to the others.

Why This Matters
You teach Claude “never do X” in the Desktop app. Next day, you open VS Code. Claude does X. You correct it again. The lesson never sticks because it was never shared.
Under the Hood

How Claude actually
stores memory.

Claude’s memory is a folder of markdown files on your computer. Each memory is a small .md file with a name, type, and description. An index file called MEMORY.md lists them all.

The Critical Detail
The folder path is derived from your working directory.
Claude takes the path you’re working from, replaces slashes with dashes, and creates a memory folder at that location inside ~/.claude/projects/.

Open Claude Desktop from your home folder? Memory goes to:
~/.claude/projects/-Users-YourName/memory/

Open Claude Code inside a project folder? Memory goes to:
~/.claude/projects/-Users-YourName-Desktop-my-project/memory/

Different paths. Different folders. No sync between them.
Real-World Discovery

What we found in a
production workspace.

After weeks of working across Claude Desktop and Claude Code, a routine audit revealed three separate memory directories with different content.

Interface Memory Path Files What It Knew
Claude Desktop ~/.claude/projects/-Users-Name/ 20 Kajabi workflows, early project notes, tech contacts
Claude Code (VS Code) ~/.claude/projects/-Users-Name-Desktop-CLAUDE/ 25 Deploy processes, writing rules, session protocols
Git repo copy Desktop/CLAUDE/.claude/projects/.../ 27 Partial superset, stale in places
The Impact
20 files knew about page building. 25 files knew about deploys. Neither knew both. Months of corrections, scattered across locations that never talked to each other.
Diagnosis

Check if you have
this problem.

Open your terminal and run these commands. Takes 30 seconds.

Step 1: Find all memory directories
find ~/.claude/projects/ -name "memory" -type d
Step 2: Count files in each
for dir in $(find ~/.claude/projects/ -name "memory" -type d); do echo "$(ls "$dir"/*.md 2>/dev/null | wc -l) files in $dir" done
What To Look For
More than one result from Step 1? You have split memory. Different file counts in Step 2? They have already diverged.
The Solution

One directory.
Symlinked everywhere.

A symbolic link tells your operating system: “when you look for files here, go look over there instead.” Claude follows the link without knowing it exists.

👀
Before
Desktop writes to Dir A
VS Code writes to Dir B
Git tracks Dir C
Nothing connects them.
→
🔗
After
One real directory (in git)
Dir A → symlink to real dir
Dir B → symlink to real dir
Same brain. Every interface.
Step by Step

How to
fix it.

01
Merge the files
Copy all unique memory files from every directory into one canonical location. For duplicates, keep the more complete version. Read them side by side if needed.
02
Back up and symlink
Rename each non-canonical directory to .bak, then create a symbolic link from the old path to the canonical directory. Claude reads and writes through the link transparently.
03
Rebuild MEMORY.md
The index file needs to reference every merged file. One line per memory, organized by category. This is what Claude scans to decide which memories are relevant.
04
Git-track the result
Add the canonical memory directory to your git repo. Now your memories are version-controlled, backed up, and recoverable. Commit after every session that changes memory.
The Actual Commands

Copy, paste,
done.

Adjust the paths to match your setup. The pattern is the same for everyone.

Back up the old directory
mv ~/.claude/projects/-Users-YourName/memory \ ~/.claude/projects/-Users-YourName/memory.bak
Create the symlink
ln -s /full/path/to/your/canonical/memory \ ~/.claude/projects/-Users-YourName/memory
Verify it works
ls -la ~/.claude/projects/-Users-YourName/memory # Should show: memory -> /path/to/canonical/memory
Important
The symlink target must be an absolute path (starting with /), not a relative one. Repeat the backup-and-symlink step for every extra memory directory you found.
For New Users

Prevent this from
day one.

If you are just getting started with Claude, do this before anything else.

Day One Checklist
Four things to do before your second session.
1. Pick one working directory. This is the folder you always open Claude from. Make it a git repo.

2. Run your first session from there. Tell Claude to remember something. This creates the memory directory.

3. Open your other Claude interface. (Desktop app or VS Code, whichever you didn’t use first.) Check if it created a second memory path.

4. If two paths exist, symlink immediately. Before they have a chance to diverge. The five-minute fix now prevents the hours-long merge later.
Bonus

Clearing sessions
without losing context.

Claude Desktop lets you clear old sessions to free disk space. This is safe as long as your work is committed. Build a pre-clear checklist into your workflow.

Pre-Clear Checklist
Run these checks before you clear anything.
✓ Uncommitted changes? Run git status. If anything is modified or untracked, commit first.

✓ Unpushed commits? Run git log origin/main..HEAD. If anything shows up, push first.

✓ Memory files tracked? Make sure your .claude/memory directory is committed to git.

✓ Active plans? Check ~/.claude/plans/ for any in-progress plans. Copy them somewhere persistent before clearing.

All green? Safe to clear. Your memories, rules, and work product live in the git repo. The chat transcripts are just conversation logs.
Reference

Quick reference.

What Details
The problem Each Claude interface stores memory in a separate directory. Multiple interfaces means multiple brains.
Who is affected Anyone using Claude Desktop AND Claude Code. That is most serious Claude users.
The symptom Corrections don’t carry over. Claude “forgets” things you already taught it in a different interface.
The fix Merge memory directories. Symlink all paths to one canonical location. Git-track it.
Prevention Set up symlinks on day one, before the directories have a chance to diverge.
Time to fix 5 minutes for a fresh setup. 15 to 30 minutes for an established workspace with diverged files.
Technical Detail

The path formula.

Every Claude memory directory follows the same pattern. Understanding this lets you predict where memory will land for any project.

# The formula: ~/.claude/projects/{working-dir-with-slashes-as-dashes}/memory/ # Example: working from /Users/jane/Desktop/my-project ~/.claude/projects/-Users-jane-Desktop-my-project/memory/ # Example: working from /Users/jane (home directory) ~/.claude/projects/-Users-jane/memory/
The Takeaway
Different working directory means different memory folder. Always open Claude from the same project folder. If you use multiple interfaces, symlink their memory paths together.
The Fix

One brain.
Every interface.

The people who get the most from Claude don’t just write better prompts. They build infrastructure that lets Claude stay coherent across every session, every tool, every context switch.

Memory is the foundation. If it’s fractured, nothing built on top of it holds together. Fix the split. Build on solid ground.

Nathaniel Solace · ThoughtLeaderAI
© 2026 Nathaniel Solace / Solace Labs. All rights reserved. · Terms & Conditions · Privacy & AI Safety