Coredence

Guide

Claude Code memory: what it remembers, and how to give it the rest

Every session starts from nothing but the files it is handed. Knowing which files those are, and what each one is good for, decides how often you explain yourself again.

Ahmet Karaca ·

A session starts empty

Claude Code does not carry a conversation from one session to the next. What it knows about you at the start of a session is whatever was loaded into its context: instruction files, notes, and anything a tool returns when it asks. Close the terminal and the conversation itself is gone; only what was written down survives.

So "memory" in Claude Code is not one feature. It is a handful of places where text can live between sessions, each loaded at a different moment and each with a different cost.

The places context can live

  • CLAUDE.md in your home folder (~/.claude/CLAUDE.md) — your instructions for every project. Loaded at the start of every session.
  • CLAUDE.md in a project — the project's own conventions, usually committed so the whole team shares them. Loaded when you work in that folder.
  • Notes Claude keeps for itself — recent versions can save short notes about a project as they learn something, and read them back next time. Useful, but they are what the model decided to remember, not what you would have chosen.
  • Skills (~/.claude/skills/<name>/SKILL.md) — longer guidance that is loaded when it is relevant rather than every time, so it costs nothing in a session that does not need it.
  • MCP servers — tools Claude can call to look something up instead of carrying it. Nothing is loaded until it asks.

Everything loaded up front is paid for in every session, in tokens and in attention. A long instruction file is not free even when it is right.

Where each one runs out

CLAUDE.md holds what you remember to write. That is its strength and its limit: the rules that matter most are often the ones you never stated, because you only noticed them when something went wrong — and by then you were fixing the thing, not editing a file.

Instruction files also drift. A line written six months ago about a library you no longer use keeps being obeyed. Nothing tells you it is stale, and nothing tells you which lines Claude actually needed.

Self-kept notes have the opposite problem: they are written without you. They are scoped to one project, they do not say why they were written, and there is no easy way to see that one of them came from a single bad afternoon.

None of them can show you the evidence. A rule in a file is a sentence; whether it is still true of you is something you have to remember.

What works in practice

  • Keep the global CLAUDE.md short, and write the reason next to each rule. "Ask before deleting files — I lost a folder of drawings once" generalises better than "never delete".
  • Put the things you correct most often at the top. Your corrections are the best record of how you work: each one is a moment where the default was wrong.
  • Move long, situational guidance into skills, so it loads only when it applies.
  • Re-read the file every few weeks and delete what is no longer true. A stale rule is worse than a missing one, because it is followed.

Where Coredence fits

Coredence does the writing-down for you, from the evidence instead of from memory. It reads your Claude Code sessions — the corrections especially — along with git history and notes if you allow it, and distils rules about how you work. Every rule keeps the moments it came from; a rule seen once waits as a draft; two rules that contradict each other become a question for you.

The result reaches Claude Code as a skill file, so it loads when it is relevant, and every MCP client — Claude, Cursor, Codex — can query it through a read-only server. The identity is one SQLite file on your machine.

You can try the real app on a made-up person's identity, in your browser, without installing anything.

Try it in your browser