THE WORLD IS NOT STANDING STILL.RSS
BIG CHANGE.
BIG CHANGE, one tap away
BIG CHANGE, one tap away

Make room for the big picture.

Add BIG CHANGE to your home screen or desktop. It opens in its own window, with the latest stories when you’re online.

iPhone & iPad
Open bigchange.ai in Safari. Tap Share, then Add to Home Screen. Turn on Open as Web App if shown, then tap Add.
Android
Open bigchange.ai in Chrome. In the browser menu, choose Install app or Add to Home screen.
Desktop
In Chrome or Edge, use the install icon in the address bar or the browser’s app menu. In Safari on Mac, choose File → Add to Dock.

Markdown edition

# Correct Claude Code project memory and check a fresh session

> Inspect and correct one owned Claude Code project memory note and its index, then check a fresh local session against the project's authoritative source.

By BIG CHANGE Editorial

Published: 2026-10-22T10:31:28.085Z
Updated: 2026-10-22T10:31:28.085Z
Canonical: https://bigchange.ai/blog/claude-code-local-project-memory-correction-guide

![Conceptual charcoal illustration of an open desktop computer with one orange-tabbed local storage drive mounted inside.](https://bigchange.ai/api/media/file/claude-code-local-memory-drive-hero-v3.png)
AI-generated conceptual illustration by BIG CHANGE.

A project correction can outlive a Claude Code chat, but only if the right local file contains the current fact and a new session can reach it. Claude Code separates instructions written by people from auto memory notes it chooses to save. This guide uses one real, owner-approved correction in a repository you control, checks the saved note and its index, and verifies the result in a fresh local process. It is based on [Claude Code's current memory manual](https://code.claude.com/docs/en/memory); BIG CHANGE did not run a Claude account or measure a memory outcome.

## The big change

- **What changed:** Claude Code gives a project two durable channels: shared instructions people maintain and machine-local memory that Claude writes from corrections and preferences. The latter has a short startup index, with detailed notes fetched only when needed.
- **Why it matters:** A developer correcting a stale project preference can inspect the actual note, repair its index pointer and check what the next local session can access. That makes the stored artifact and its scope visible, while an answer alone cannot establish which source the model used.
- **What to watch:** The next session's effective settings and file reads decide whether this correction is available. A different machine, a disabled memory setting or a topic file that was never opened changes the result even when the old session sounded certain.

## 1. Choose the actual project and durable channel

Use a repository you own or are authorized to maintain. Identify one approved, non-sensitive correction or preference and the project record that establishes its current wording. Do not invent a test fact. In a terminal, check the installed client version:

```text
claude --version
```

Check the account or provider you intend to use, and whether sending this specific project material to that provider is approved. A local Markdown file does not make model processing local. A real session uses subscription allowance or API/provider usage; `/usage` reports an estimate, not an invoice.

Before editing, read the current root and ancestor instruction files, relevant nested files, imports and `.claude/rules/`. Inspect user, project, local and managed settings, the `/config` Project instructions choice, and `/permissions`. Those settings can change which files load and whether auto memory is enabled. Check whether another person, agent or worktree is writing the same file, then agree on one editor or pause your edit. Worktrees and subdirectories of a repository normally share its local auto memory directory.

Put a team rule that should guide everyone in an owned project instruction file such as `CLAUDE.md` or `.claude/CLAUDE.md`, after the project's normal review. A tracked file can reach collaborators through Git. An individual project preference that does not belong in source control may fit `CLAUDE.local.md`. Auto memory is for useful corrections, preferences and project context Claude cannot derive from code; Claude decides what to save and may save nothing in a session. Do not copy an existing instruction into auto memory to make it appear twice. These files supply context, not a permission boundary or a guarantee of compliance. [The official memory guide](https://code.claude.com/docs/en/memory) describes the scopes and the default loading behavior.

If this repository uses `AGENTS.md`, check the installed version and effective Project instructions setting before relying on it. Direct reading requires Claude Code 2.1.277 or later. By default, a project or ancestor `CLAUDE.md` or `CLAUDE.local.md` takes precedence over `AGENTS.md`; an `@AGENTS.md` import can include it. The older provider and telemetry restriction applied before 2.1.281 and should not be treated as a current universal condition. Verify loaded instructions in the actual session rather than assuming a filename was picked up. An import adds its content to context and can require approval when it reaches outside the working directory.

At this point you should have the actual project, approved correction and authoritative source, installed version, effective instruction path and an agreed owner for the edit.

## 2. Inspect and correct local auto memory

In the intended project, open `/memory` and inspect the auto memory state and folder. Its list includes some instruction-file locations that do not exist yet; selecting one can create it. The listing alone cannot prove a file contains the approved text or that a topic note loaded. If auto memory is disabled by project or managed settings, an environment variable, or the session type, leave that decision intact. You can still complete an approved instruction-file update, but cannot claim an auto-memory correction passed.

The default folder is `~/.claude/projects/<project>/memory/`. `CLAUDE_CONFIG_DIR`, `CLAUDE_CODE_PROJECT_DIR_NAME` and the `autoMemoryDirectory` setting can change the effective location, so use the path shown in your session and inspect the relevant settings. Read the actual `MEMORY.md` index and the topic file holding the correction. Compare the note with the owner's current source and applicable project files. Read the bytes again immediately before changing them, especially when another session might have written to the same memory directory.

Make the smallest authorized edit to the stale topic note and adjust its `MEMORY.md` entry so the index points to the right current note. If the owner has explicitly decided an obsolete note should be removed under the project's retention policy, remove only that note and its index pointer. Preserve unrelated notes. Read the corrected topic file and index back from disk, and confirm an authorized deletion by checking both the file's absence and the removed pointer. Deleting these local files does not erase older transcripts, backups or provider records.

Keep the index brief. Claude Code loads only the first 200 lines or 25 KB of `MEMORY.md`, whichever comes first, at the start of a conversation. Detailed topic files are read on demand. The manual recommends keeping `CLAUDE.md` under 200 lines for clarity, but loads a file up to 4 MiB in full and skips larger ones. These are different limits. A correct note that sits outside the loaded index boundary, or whose topic file is never read, has not passed a fresh-session availability check.

At this point the reviewed note and its current index pointer should match the approved source on disk; any owner-authorized obsolete note and pointer should both be absent.

## 3. Check from a genuinely fresh local process

After the old process is closed, open a new terminal in the verified repository directory and start a fresh interactive Claude Code session:

```text
claude
```

Do not use resume or continue. Record the working directory and effective memory folder. Run `/context` to confirm the applicable instruction files loaded; use `/memory` to confirm the local folder and index. A nested instruction may load only when a relevant file is accessed. For auto memory, check that the index entry falls inside its startup boundary and that the session actually opens the topic file when the question needs it. Inspect the file directly if the read is uncertain.

Ask about the chosen real project correction without supplying its answer in the question. Compare the response independently with the owner-approved source and the saved file text. A matching answer is useful but cannot prove the model internally relied on memory. The strongest available readback is the reviewed file, applicable load or topic-file access, and an answer that agrees with project authority. Record each separately. If the answer is wrong, the topic file was not read, or the setting is disabled, mark the auto-memory check incomplete. Repair the specific path, scope, conflicting instruction or index entry and repeat the fresh-process check after verifying the change on disk. Do not overwrite an uncertain concurrent edit.

For a team instruction, the comparable check is the reviewed file's saved text, its appearance in `/context` when applicable, and an answer checked against the project's authority. That result says nothing about whether auto memory is active. For a related guide on checking instruction scope between projects, see [our two-client Claude Code walkthrough](https://bigchange.ai/blog/claude-code-client-project-instruction-scope-guide).

The result to keep is a fresh-process record of applicable loaded files or the needed topic-file read, plus an answer independently checked against the approved project source; record any missing part as incomplete.

## Sources & further reading

- [Claude Code: How Claude remembers your project](https://code.claude.com/docs/en/memory). Explains instruction scopes, AGENTS.md version and setting conditions, local auto-memory storage, index limits, `/context` and `/memory` checks, and note editing. Checked 22 October 2026; the page states no fixed publication date.
- [Claude Code: CLI reference](https://code.claude.com/docs/en/cli-reference). Confirms `claude` starts a new interactive session, while continue and resume are separate commands or flags. Checked 22 October 2026.
- [Claude Code: Configure permissions](https://code.claude.com/docs/en/permissions). Explains effective file and tool permissions, managed settings and working-directory scope. Checked 22 October 2026.
- [Claude Code: Manage costs effectively](https://code.claude.com/docs/en/costs). Distinguishes subscription use, API usage and the estimate shown by `/usage`. Checked 22 October 2026.

## Sources

- [Claude Code: How Claude remembers your project](https://code.claude.com/docs/en/memory) — Checked 22 October 2026; no fixed publication date stated. Instruction scope, AGENTS.md conditions, auto-memory state and path, index limits, on-demand reads, /memory and /context.
- [Claude Code: CLI reference](https://code.claude.com/docs/en/cli-reference) — Checked 22 October 2026. Bare claude starts an interactive session; continue and resume use separate flags or commands.
- [Claude Code: Configure permissions](https://code.claude.com/docs/en/permissions) — Checked 22 October 2026. Effective tool and file permissions, managed settings and working-directory scope.
- [Claude Code: Manage costs effectively](https://code.claude.com/docs/en/costs) — Checked 22 October 2026. Subscription and API usage routes and /usage estimate limits.