How Claude Code Projects' Shared Memory Actually Works: One MEMORY.md Decides What Every Parallel Thread Knows

Is what gets written into MEMORY.md decided automatically by Claude, or can I actively ask it to remember something specific?

Going by Anthropic's own examples — "the release moved to Friday," "who to check with before touching billing code" — this kind of information sounds like it naturally surfaces during conversation, with Claude judging it as decision-level, rule-level content worth writing into the index on its own. That suggests the mechanism leans automatic, not something that only happens every time you explicitly say "remember this."

That said, if something genuinely matters to you, the more cautious approach is still to state it explicitly in conversation, rather than assuming Claude will automatically recognize its importance and write it into MEMORY.md on its own. This is, after all, an index Claude actively maintains, and you currently have no way to see its full judgment logic directly in documentation. Rather than discovering after the fact that a key decision never got remembered, it's safer to say it explicitly in the moment and lower the risk of it being missed.

Why do memory and code context take two separate inheritance paths instead of just being bundled into one index?

The two are fundamentally different in nature. Code context — the repository itself, CLAUDE.md, skills, plugins — is the actual material each thread needs to operate on, edit, and test while doing its work. This content can be substantial in size, and each thread generally needs a complete, independent copy so parallel threads don't interfere with each other. If this content were also crammed into an index file like MEMORY.md, the index itself would become bloated and inefficient, and you'd lose the basic premise that makes parallel execution work: each thread having its own independent working copy.

Memory — the content inside the MEMORY.md index — is the opposite: its value comes specifically from being lightweight, shared across threads, and continuously accumulating. This kind of decision-level information is usually short, but needs to be visible to every subsequent thread — it doesn't need, and shouldn't need, an independent copy per thread the way code does (multiple copies would actually create a risk of information going out of sync). Splitting these into two different mechanisms happens because they land on opposite answers to the questions of whether to share and whether to keep an independent copy.

If my project spans multiple repositories, what's the actual practical impact of permission rules only applying within the launch directory?

The practical impact is this: a permission rule you set within one repository — a specific deny rule, a hook — doesn't automatically extend to other repositories within the same project. If a thread launches from a different repository's directory, it isn't bound by the rules you set in the first repository, unless you've separately configured the corresponding rules in that repository too. That means in a multi-repository project, how tightly permission rules actually govern behavior depends on whether you've set them up individually in every single repository — not something you configure once and it protects the entire project.

The more reliable practical approach is to first inventory exactly how many repositories your project spans, then individually check whether permission rules, hooks, and env are set as you expect in each one — rather than assuming, because you configured rules in one repository, that the same protection now applies across the whole project. That assumption holds true for a single-repository project, but stops holding once a project spans multiple repositories.

If the coordinator can't see every step a thread takes and only sees the reported result, does that create a problem for actually supervising progress?

That means if you only watch the project conversation itself, what you can track is high-level progress — what stage this thread is at now, what it eventually reported — not execution-level detail like "it tried three approaches, the first two failed." For most situations where you just need to know the outcome, this level of information is already sufficient, and you don't need to watch every single step.

But if a thread's result isn't what you expected, or you need to understand why it made a specific choice, information from the coordinator layer alone won't be enough — you need to actively open that specific thread to see the full execution process and intermediate attempts. So a more practical supervision habit is to treat the coordinator conversation as a dashboard for checking progress, and only click into an individual thread for details when something the dashboard shows raises a question, or the result itself needs closer scrutiny — you don't need, and realistically can't, watch every parallel thread the whole way through.