AI Agent Memory: How Claude Remembers You Between Sessions

Agent memory in plain English

Picture a new barista at your favorite coffee shop. Day one, you tell them: oat milk cappuccino, no sugar. They nod, make it, perfect. The next day you walk in and it’s right back to “How do you take it?” And the day after. And a week later. Every. Single. Time. From scratch.

Annoying, right? That’s exactly how a bare model behaves. Within a single conversation it’s brilliant - it remembers every little detail. But close the chat and you’re a stranger to it all over again. Not because it’s dumb. It literally has nowhere to keep notes on you between visits.

Now picture that barista keeping a little notebook: regular, cappuccino, oat milk, no sugar. They open it in the morning, read it, and greet you like an old friend. That notebook is the agent’s memory. And the whole trick is in what you write there and how.

Why a vibecoder should understand AI memory

You’re a vibecoder. You run an agent through your project day in, day out. Once you get how it remembers, a few things click into place at once:

• you stop explaining the same thing for the tenth time - the agent picks up your habits on its own;
• you know where to put an important rule so it survives a restart;
• you stop getting blindsided by the classic “new chat - forgot everything - did its own thing”;
• you understand why the agent sometimes confidently does it the way you like and sometimes plays it safe.

The whole difference between “starting from zero every time” and “the agent already knows my project” comes down to three things: where the memory lives, what form it takes, and how much the agent trusts it. Let’s break it down.

How Claude’s memory is built: instincts, confidence, and scope

In smart memory systems (like the continuous-learning Continuous Learning is a system of ongoing learning: it watches your sessions and pulls tiny habit-rules out of them on its own. The more often a pattern repeats, the more confident the agent becomes in it. skill), the agent doesn’t dump everything into the notebook. It writes neat little chunks. The whole thing rests on three pillars.

An instinct is a single habit, not a wall of text

Memory isn’t written in paragraphs like “here’s what happened yesterday.” It’s written as instincts An instinct is a tiny learned rule of the form when X, do Y. It's atomic: one trigger, one action. For example: when I write a new function, use a functional style. . An instinct is an atomic building block: one trigger, one action. That’s it.

For example: when I write a new function, do it in a functional style. Or: when I save a file, read it first. Small, specific, no fluff. Blocks like these are easy to add, easy to verify, and no big deal to toss out once they’re outdated.

Confidence is how much the agent trusts a habit

Every instinct has a number attached - a confidence Confidence is a number from 0.3 to 0.9 showing how much the agent trusts a habit. 0.3 means it'll only suggest; 0.9 means it does it as a matter of course. from 0.3 to 0.9. That’s the difference between “no sugar, right?” and “oat milk cappuccino, the usual - pouring it now.”

Confidence rises when a habit repeats and you don’t correct it. And it falls when you say “no, not like that” or the pattern hasn’t come up in a while. So memory isn’t set in stone - it lives and adapts to you.

Memory scope: a rule for one project or for everything

Here’s the part beginners trip over. Memory lives in two scopes:

• Per project - it only applies inside that one project. This is where language and framework conventions go: use React hooks, put tests in the tests folder, the style here is such-and-such.
• Global - it applies everywhere. This is where universal truths go: always validate user input, write tests, read the file first, then change it.

Good memory vs. bad memory: the pros and cons

Agent memory in practice: a real example

You spend a week building a site. And every single time you dictate to the agent from scratch: 8-pixel spacing, rounded buttons, text in Russian. By day five it’s a real headache, and you genuinely don’t get why it just won’t remember.

Of course it doesn’t - you never gave it a notebook. A vibecoder who gets it does it differently: you ask the agent once to set up a memory file and stash habits in it. From then on, the notebook keeps itself.

Set up a MEMORY file in this project with my habits and maintain it yourself.
Rules for keeping it:

Write short bullet points in the style of “when I do X, do Y.” One bullet, one fact.
What we already know: 8-pixel spacing, rounded buttons, all text in Russian.
If I correct you, update the relevant bullet - don’t spawn duplicates.
If a fact is outdated or conflicts with a new one, delete the old one - don’t keep both.
No passwords, keys, or secrets in this file.
At the start of every new session, read this file first, then start the task.

Why the agent forgot your habits: a diagnostic checklist

Agent forgot your habits? Run through the checklist before you lose it:

1. Is the rule actually in a file? Said it once in the chat? After a restart it’s gone. Move it into memory.
2. Any duplicates or contradictions? If memory holds both do A and never A, the agent will flip-flop. Clean it up.
3. Is it a junk pile? The memory file has ballooned into a wall of text - break it into short, atomic bullets.
4. Is the rule from another project? A local habit may have wandered to the wrong place. Check where it lives.
5. Has the fact gone stale? The agent genuinely trusts an old note. If everything in the project changed, update the entry.

Common beginner mistakes with memory

• Believing the AI will remember on its own. Without a memory file, it starts every session with a blank slate.
• Keeping rules only in the chat thread. Close the chat and the rules are gone. Move them into a file.
• Writing memory as walls of text. The agent will drown in it. Chop it into short “when X, do Y” bullets.
• Hoarding and never cleaning up. Old, contradictory notes confuse the agent worse than an empty file.
• Stashing secrets in memory. A file will leak one day. Passwords and keys - never in memory.
• Being surprised a habit didn’t fire in another project. Per-project memory is locked to its own project - that’s a feature, not a bug.