Система памяти (memory): как заставить его помнить вас между сессиями
📚 Навигация по серии: В предыдущей статье [24 Плагины (Plugins)] мы рассказали, как упаковать кучу разрозненных настроек в плагины, которые устанавливаются и останавливаются в один клик. В этой статье мы поговорим о более фундаментальной вещи — как заставить Claude помнить вас между сессиями. И это не только CLAUDE.md, который вы пишете вручную, но и та «личная записная книжка», которую он собирает сам в процессе работы. Вы исправляете его один раз, он тихонько это записывает и автоматически вспоминает при следующей работе.
Начнем с ловушки, в которую особенно легко попадают новички.
Когда вы только обнаруживаете функцию «заставить Claude запоминать», очень легко обрадоваться, как будто вы нашли сокровище, и запихивать в нее все подряд: сегодня настроили номер порта — записали, изменили имя временной переменной — записали, даже такие одноразовые вещи, как «в этот раз сначала используем 8081, а не 8080» — тоже записали. За этим часто стоит логика: «чем больше он помнит, тем умнее становится».
И что в итоге? Вы открываете проект через две недели, и он сходу предлагает вам тот давно устаревший порт 8081 и несколько «предпочтений», которые вы сами забыли, зачем написали. Он забил голову бесполезным мусором, а то, что действительно нужно было запомнить, утонуло.
В этот момент вы понимаете: с памятью работает правило не «чем больше запихнешь, тем лучше», а «запоминать то, что нужно, и не трогать то, что не нужно». Запоминать неправильно — хуже, чем вообще не запоминать, потому что он будет на полном серьезе вводить вас в заблуждение устаревшей информацией.
Ранее в [18 Руководство по использованию CLAUDE.md] мы подробно рассказывали, как писать CLAUDE.md, а в [19 Управление контекстом] мы неоднократно упоминали, что «автоматическая память занимает контекст». Но как именно эти две части соединяются в единую «систему памяти», и как работает та записная книжка, которую Claude пишет сам, мы до сих пор не разбирали подробно. Сегодня мы это исправим.
Прочитав эту статью, вы узнаете:
- На какие две системы делится память Claude Code: CLAUDE.md, который пишете вы, vs «автоматическая память», которую пишет он сам. Кто за что отвечает — понятно из одной таблицы.
- В каком файле хранится «автоматическая память», как она загружается в контекст, и как использовать
/memoryдля аудита, редактирования и удаления. - Как заставить его запомнить правило, куда оно сохраняется, и как автоматически применяется в следующий раз — пошаговое руководство.
- Список «что запоминать vs что не запоминать», который поможет вам избежать ловушки «запихивать все подряд».
- Работает ли еще старый шорткат
#, и каков сейчас правильный официальный подход.
01 Для начала разберемся: память — это на самом деле две системы, а не одна
Сразу к выводу: «Память» в Claude Code — это две параллельные системы: одну пишете вы, другую пишет он, и каждая отвечает за свое. Многие, когда слышат слово «память», думают только о CLAUDE.md, но на самом деле это лишь половина.
Аналогия: стикеры на краю монитора. У вас на столе обычно есть два типа бумаг. Первый — это «правила работы», которые вы официально распечатали и прикрепили кнопкой на перегородку: правила проекта, процесс коммитов, все написано четко, и кто бы ни пришел, он следует им. Это CLAUDE.md. Второй — это стикер, который вы на ходу оторвали, написали «в прошлый раз баг был из-за того, что не очистили кэш», и прилепили на край монитора. В следующий раз вы бросите на него взгляд и вспомните. Такие маленькие заметки, которые он делает для себя на ходу, и есть «автоматическая память (auto-memory)». Оба типа бумаг перед вашими глазами, но один — это «правила, которые я установил», а другой — «опыт, который я записал по пути».
Официальная документация очень четко объясняет разделение труда между этими двумя системами и представляет их в виде сравнительной таблицы — ее стоит запомнить в первую очередь:
| Измерение | Файл CLAUDE.md | Автоматическая память (auto-memory) |
|---|---|---|
| Кто пишет | Вы (вручную) | Claude (сам) |
| Что содержит | Инструкции и правила | Опыт и паттерны, которым он научился |
| Типичный контент | Стандарты программирования, рабочие процессы, архитектура проекта | Команды сборки, инсайты отладки, обнаруженные им ваши предпочтения |
| Когда загружается | В каждой сессии, загружается полностью | В каждой сессии, но загружаются только первые 200 строк или 25KB |
| Область действия | Уровень пользователя / проекта / локальный | Одна копия на каждый git-репозиторий (общая для всех worktree) |
Видите ключевую разницу? CLAUDE.md — это «как вы хотите, чтобы он работал», а автоматическая память — это «как он сам понял, как нужно работать». Вы поправляете его: «чтобы запустить тесты в этом проекте, сначала нужно поднять локальный Redis», и в следующий раз он это вспомнит. Это правило не нужно вручную писать ни в какой файл, он сохранит его сам.
Есть еще один момент, который официально неоднократно подчеркивается, и который вы должны усвоить с самого начала:
Claude рассматривает их как контекст, а не как обязательную конфигурацию. Чтобы запретить какое-либо действие, независимо от того, что решит Claude, используйте вместо этого hook PreToolUse.
Что это значит? Память (неважно, какая из систем) — это лишь «мягкие подсказки», влияющие на то, что он хочет сделать, а не «жесткие ограничения», блокирующие то, что он может сделать. Это перекликается с выводами из статьи [20 Настройка разрешений]: если вы действительно хотите заблокировать какую-то операцию, вам нужно полагаться на правила разрешений или hook. Просто написать в памяти «не делай push» не поможет его остановить. Память отвечает за то, чтобы он «лучше вас понимал», а не за то, чтобы «выполнять функции контроля».
💡 Краткий итог: Память делится на две системы — CLAUDE.md, где вы вручную пишете правила, и автоматическая память, куда он сам записывает опыт; обе системы — это только мягкие подсказки. Если вы хотите жестко заблокировать операцию, нужно использовать разрешения или hook, просто записать это в память недостаточно.
На этой схеме два пути памяти нарисованы рядом: слева — CLAUDE.md (правила проекта), который вы пишете вручную и который полностью загружается в контекст; справа — автоматическая память (личная записная книжка), которую Claude сам заполняет в MEMORY.md во время работы и из которой автоматически считывает первые 200 строк в следующей сессии. Обе линии в итоге сходятся в «контекстном окне новой сессии», чтобы он «помнил вас» с самого начала работы.
02 Место CLAUDE.md в системе памяти
О том, как писать CLAUDE.md, мы уже подробно говорили в [18], поэтому здесь добавим лишь одно о его роли в «системе памяти» — это те самые прибитые гвоздями «правила работы», которые должны читать все.
Аналогия: опять же, из тех двух бумажек у монитора, CLAUDE.md — это та, что прибита гвоздями. Это не наспех оторванный стикер, это официальные правила, которые вы распечатали и надежно закрепили кнопкой. Поэтому у него есть несколько особенностей, которые полностью отличают его от автоматической памяти: он пишется вами, помещается в систему контроля версий (общедоступен для команды), полностью загружается в каждой сессии, а его содержание — это «правила», а не «опыт».
Официально для CLAUDE.md определена четкая иерархия по порядку загрузки (от самой широкой к самой конкретной):
| Уровень | Расположение | На кого распространяется |
|---|---|---|
| Уровень управляемой политики | macOS: /Library/Application Support/ClaudeCode/CLAUDE.mdLinux/WSL: /etc/claude-code/CLAUDE.md | Централизованно распространяется корпоративным IT-отделом, обычных пользователей обычно не касается |
| Уровень пользователя | ~/.claude/CLAUDE.md | Ваши личные предпочтения для всех ваших проектов |
| Уровень проекта | ./CLAUDE.md или ./.claude/CLAUDE.md | Для этого проекта, общедоступно для команды (входит в git) |
| Локальный уровень | ./CLAUDE.local.md | Для этого проекта, только для вас (добавляется в .gitignore) |
Здесь есть ключевое отличие от автоматической памяти, которое новички должны запомнить навсегда:
CLAUDE.md полностью загружается независимо от его длины, в то время как автоматическая память имеет лимит. Официальная цитата: «Файл CLAUDE.md загружается полностью независимо от его длины». Именно поэтому в [18] мы неоднократно советовали вам ужимать его до 200 строк: дело не в том, что он не загрузится, а в том, что чем длиннее вы его пишете, тем больше контекста он занимает и тем хуже он соблюдается. С автоматической памятью все наоборот, у нее есть жесткий лимит (о нем мы поговорим подробно в следующем разделе), и то, что превышает этот лимит, вообще не загружается.
На практике разделение труда может быть очень четким: «Это жесткое правило, которое вы установили» — пишите в CLAUDE.md, «Это то, что он может понять и накопить сам» — отдайте автоматической памяти. Например, железное правило «использовать только pnpm для зависимостей» нужно прописать вручную в CLAUDE.md; а то, что «для тестов в этом проекте нужно запустить Redis», он может обнаружить сам, это не нужно писать вручную, просто поправьте его один раз, и он запомнит это сам.
💡 Краткий итог: CLAUDE.md — это те «прибитые гвоздями официальные правила» в системе памяти. Вы его пишете, команда им делится, он полностью загружается, и он содержит правила. Это совершенно другая роль по сравнению с автоматической памятью, где «он сам на ходу записывает опыт».
03 Автоматическая память: та самая записная книжка, которую он ведет сам
А теперь главное, то, ради чего мы и затевали эту статью в [18] — автоматическая память (auto-memory), записная книжка, которую Claude ведет для себя во время работы.
ℹ️ Автоматическая память требует версии Claude Code v2.1.59 или выше, и она включена по умолчанию. Введите
claude --version, чтобы проверить свою версию; если она слишком старая, обновите ее (инструкции по обновлению см. в [02 Установка]).
Аналогия: старый напарник, с которым вы давно работаете. Напарнику, с которым вы давно работаете, вам не нужно повторять некоторые вещи снова и снова — он сам запоминает их: «Для сборки этого проекта нужно запускать make build, а не npm build», «В прошлый раз этот случайный баг был из-за того, что не настроили часовой пояс». В следующий раз, когда он столкнется с чем-то подобным, он вспомнит об этом сам. Вам не нужно ему объяснять, он накапливает знания в процессе работы — автоматическая память — это именно такая способность Claude к «активному обучению».
Что конкретно он записывает? Официальный список: команды сборки, инсайты отладки, заметки об архитектуре, предпочтения в стиле кода, привычки рабочего процесса. Обратите внимание на ключевой момент в дизайне: он не записывает туда все подряд в каждой сессии, а «решает, стоит ли это записывать, основываясь на том, пригодится ли эта информация в будущих диалогах». Одноразовую ерунду он обычно не записывает (это как раз лечит болезнь «запихивать все подряд»).
Как именно это записывается на практике? Есть два способа запуска:
Первый: вы прямо просите его запомнить. Скажите в диалоге: «В будущем в этом проекте всегда используй pnpm, не используй npm» или «Запомни, что для тестирования API нужно локально запустить Redis», и он сохранит это в автоматическую память. Официальная цитата:
Когда вы просите Claude запомнить что-то, например, «всегда используй pnpm, а не npm» или «запомни, что для тестирования API нужен локальный экземпляр Redis», Claude сохраняет это в автоматическую память.
Второй: он сам учится на ваших исправлениях. Вам не нужно прямо говорить «запомни», достаточно исправить его один раз. Например, он использует npm test, а вы говорите: «В этом проекте нужно pnpm test» — он решит, что это пригодится в будущем, и сам это запишет. Это самая крутая фишка автоматической памяти: вы нормально работаете, нормально его поправляете, а он молча накапливает знания в фоновом режиме, без каких-либо дополнительных действий с вашей стороны.
Как вы узнаете, что он сейчас это записывает? Посмотрите на подсказки в интерфейсе. Официальная документация говорит, что когда вы видите в интерфейсе Claude Code всплывающее сообщение «Writing memory» или «Recalled memory», это значит, что он пишет в эту записную книжку или читает из нее.
💡 Краткий итог: Автоматическая память — это стикеры, которые Claude пишет сам: вы просите его запомнить, или он учится на ваших исправлениях, он запоминает только то, что «пригодится в будущем»; если вы видите в интерфейсе подсказку «Writing/Recalled memory», это значит, что он записывает или листает записную книжку.
04 Где она хранится и как загружается в контекст
В этом разделе мы ответим на два самых практичных вопроса: в каком файле на самом деле хранится эта записная книжка? И как она помещается в контекст, чтобы Claude «вспомнил»? Вторая часть как раз перекликается с управлением контекстом, о котором мы говорили в [19].
Место хранения официально закреплено — для каждого проекта создается отдельный каталог памяти:
~/.claude/projects/<project>/memory/
├── MEMORY.md # Краткий индекс, загружается в каждой сессии
├── debugging.md # Подробные заметки, связанные с отладкой
├── api-conventions.md # Решения по дизайну API
└── ... # Другие тематические файлы, созданные самим ClaudeДавайте разберем несколько ключевых моментов:
MEMORY.md — это точка входа и индекс. Это как «оглавление» в стикерах, Claude использует его, чтобы отслеживать «что я вообще записал». Подробное содержание он разбивает по тематическим файлам, таким как debugging.md или api-conventions.md, чтобы MEMORY.md не раздувался.
Имя <project> определяется по git-репозиторию. Так что — все worktree и подкаталоги одного репозитория используют эту единственную копию автоматической памяти. Это отличается от CLAUDE.md (CLAUDE.md склеивается по дереву каталогов).
Она хранится локально на машине и не синхронизируется между устройствами. То, что вы сохранили на этом компьютере, не появится на другом. И не надейтесь, что она попадет в git — она просто лежит в вашем ~/.claude.
Теперь о самом важном механизме, который нужно понять — как она загружается в контекст. Официальные правила очень жесткие:
Первые 200 строк или первые 25KB файла
MEMORY.md(в зависимости от того, что наступит раньше) загружаются в начале каждого диалога. Содержимое, превышающее этот порог, не загружается при запуске сессии.
Переводя на человеческий язык, это означает три вещи:
- В каждой новой сессии автоматически считываются первые 200 строк
MEMORY.md(или 25KB, что наступит раньше). Это и есть принцип того, как он «помнит между сессиями» — то, что было записано в прошлый раз, автоматически попадает в контекст на старте этой сессии. - То, что превышает 200 строк / 25KB, на старте не загружается. Поэтому Claude проактивно поддерживает файл
MEMORY.mdкомпактным, а подробности сбрасывает в тематические файлы. - Тематические файлы (такие как
debugging.md) на старте тоже не загружаются, он читает их по мере необходимости, используя инструменты для работы с файлами — это тот же принцип «загрузки по требованию CLAUDE.md в подкаталогах», о котором мы говорили в [18].
Если сравнить правила загрузки CLAUDE.md и автоматической памяти, разница очевидна:
| CLAUDE.md | Автоматическая память MEMORY.md | |
|---|---|---|
| Сколько загружается | Полностью, какой бы длины ни был | Только первые 200 строк / 25KB |
| Что происходит с избытком | Все равно загружается полностью (поэтому советуем писать коротко) | На старте не загружается, читается только по необходимости |
| Кто следит за краткостью | Вы вручную удаляете | Claude автоматически разбивает на части |
Поняв этот лимит, вы поймете, почему память не может «разорвать» контекст — у автоматической памяти от природы есть затвор на 200 строк, в то время как затвором CLAUDE.md должны управлять вы сами.
💡 Краткий итог: Автоматическая память хранится в
~/.claude/projects/<project>/memory/MEMORY.md, она привязана к git-репозиторию, локальна для машины и общая для worktree; на старте каждой сессии считываются только первые 200 строк / 25KB, а все, что выходит за рамки, разбивается на тематические файлы и читается по необходимости — поэтому у нее есть естественный предел, и она не переполнит контекст.
05 /memory: аудит, редактирование, переключатель — все в одной команде
Самое большое опасение по поводу автоматической памяти: она ведет записи сама, что если она запишет что-то не так или сохранит устаревшую информацию? (Отсюда и взялась ловушка с портом 8081 в начале статьи). Официальный ответ — одна команда: /memory.
Аналогия: стопка стикеров, которую можно просмотреть в любой момент. Записная книжка, которую он ведет для себя — это не черный ящик. Вы можете в любой момент заглянуть в нее и оторвать любой стикер. Команда /memory — это и есть действие «заглянуть».
Если ввести /memory в сессии, она выполнит три действия:
- Покажет список всех файлов памяти, загруженных в текущей сессии — включая CLAUDE.md, CLAUDE.local.md, файлы правил и автоматическую память. Если вы подозреваете, что он «запомнил что-то не то», сначала используйте эту команду, чтобы проверить, что именно загрузилось.
- Предоставит вход в папку автоматической памяти — одним кликом вы попадете в каталог
memory/, где все эти файлы — это чистый markdown, который вы можете читать, изменять и удалять в любое время. Ту запись, которую он понял неверно, можно просто удалить. - Переключатель автоматической памяти — если вы не хотите, чтобы он автоматически запоминал информацию, вы можете отключить это здесь.
Помимо использования /memory в сессии, есть еще два официальных способа «зафиксировать переключатель»:
Отключить автоматическую память в settings.json (уровень проекта, действует постоянно через файл конфигурации):
{
"autoMemoryEnabled": false
}Или временно отключить ее с помощью переменной окружения (просто установите CLAUDE_CODE_DISABLE_AUTO_MEMORY=1).
Стоит завести привычку: время от времени вводить /memory, чтобы просматривать записную книжку своего проекта. Часто можно найти несколько записей, которые давно пора было удалить — измененный порт, устаревшее соглашение по API, «предпочтение», которое вы сами уже не понимаете. Это дело двух минут, и это спасет вас от ситуации, когда он однажды начнет вводить вас в заблуждение устаревшей информацией. Это и есть тот урок, который можно извлечь из ловушки с портом 8081.
💡 Краткий итог: Команда
/memoryраскрывает всю систему памяти — показывает загруженные файлы, позволяет открыть папку автоматической памяти для чтения/изменения/удаления, а также включает или выключает автоматическую память; регулярно заглядывать и удалять устаревшие записи — самый простой способ вылечить проблему «он запомнил неверно».
06 Что запоминать, а что нет: не повторяйте ошибку «запихивать все подряд»
С механизмами разобрались, перейдем к самому практичному вопросу — что стоит заставить его запомнить, а к чему лучше вообще не прикасаться. Этот раздел полностью основан на опыте, полученном ценой набитых шишек.
Хорошая новость в том, что автоматическая память по умолчанию довольно сдержанна (запоминает только то, что «пригодится в будущем»). Но когда вы просите его запомнить что-то проактивно, вам нужно фильтровать это самому — если вы скажете «запомни xxx», он обычно это запишет, и контроль полностью в ваших руках.
Вот сравнительная таблица. Слева — то, о чем вы пожалеете, если запишете, справа — то, что действительно стоит запомнить:
| ❌ Не заставляйте его запоминать (одноразовое / изменится / конфиденциально) | ✅ Стоит запомнить (стабильное / переиспользуемое / специфика проекта) |
|---|---|
| «В этот раз сначала используем порт 8081» (одноразовое) | «Команда сборки — make build, а не npm build» |
«Временно переименуй эту переменную в tmp» (временное) | «В этом проекте для тестов нужно сначала локально запустить Redis» |
| «В этой версии пусть пока работает так» (скоро изменится) | «В прошлый раз корень случайного бага был в том, что не настроили часовой пояс» (инсайт отладки) |
| Пароли баз данных / API key / token (конфиденциально!) | «Формат даты всегда используем ISO 8601» (соглашение, предпочтение) |
| «Я сейчас отлаживаю страницу входа» (временное состояние) | «Вся логика аутентификации находится в src/auth/» (факт об архитектуре) |
Три принципа для принятия решения, запомните только эти три фразы:
Первый: «Изменится ли это?». Одноразовые, скоро меняющиеся вещи, то, что «пока оставим так» — не записывайте ничего из этого. Их срок годности короче вашей текущей сессии, записывать их — значит рыть яму на будущее. Тот самый порт 8081 — типичный пример: он был полезен в тот момент, когда вы его настраивали, а через пару дней стал дезинформацией.
Второй: «Можно ли это переиспользовать?». Записывайте только то, что пригодится не только в этот раз («я сейчас отлаживаю X» — не записывать), но и в следующий, и через раз (команды сборки, факты об архитектуре, набитые шишки). Только это достойно памяти.
Третий: «Насколько это конфиденциально?». Это красная линия — пароли, токены, API-ключи и тому подобное категорически нельзя помещать ни в какие файлы памяти. Автоматическая память хранится в виде простого текста в формате markdown на вашем жестком диске. Записывать туда ключи — все равно что хранить их на диске в открытом виде. Это соответствует глобальным ограничениям безопасности: конфиденциальная информация не должна попадать в код, в коммиты, в логи, и, естественно, в память.
Прежде чем заставить его запомнить что-либо, пропустите это через эти три фильтра: Изменится ли это? Пригодится ли в будущем? Конфиденциально ли? Просите запомнить только то, что прошло все три проверки. После такого контроля его записная книжка станет намного чище, и он больше не будет вводить вас в заблуждение устаревшей информацией.
💡 Краткий итог: Перед записью пропустите через три фильтра — то, что изменится, не записывайте; то, что используется один раз, не записывайте; конфиденциальное — категорически не записывайте; запоминайте только «стабильные, переиспользуемые, специфичные для проекта» факты и инсайты. Не запихивайте туда все подряд.
07 Старый шорткат #: можно ли его еще использовать?
ℹ️
#— это старый подход, в новых версиях он больше не используется. Многие старые туториалы и видео все еще учат «использовать#в начале для быстрого добавления в память» — просто забудьте об этом. Правильный подход сейчас: сказать «запомни xxx» для сохранения в автоматическую память, сказать «добавь в CLAUDE.md» для сохранения в git-правила, а для проверки, изменения или удаления использовать/memory.Ошибка, которую чаще всего совершают новички: если просто сказать «запомни xxx», это по умолчанию сохранится в автоматическую память (локально на машине), и это не то же самое, что попадание в CLAUDE.md (в git, общедоступно для команды). Если вы хотите, чтобы вся команда видела какое-то правило, нужно четко сказать «добавь в CLAUDE.md». Одно предложение делает огромную разницу в области видимости.
💡 Краткий итог: Шорткат
#устарел, не используйте его; «запомни xxx» идет в автоматическую память, «добавь в CLAUDE.md» — в git. Это не одно и то же, если хотите поделиться с командой — говорите это прямо.
08 Практика: записываем одно правило, проверяем, куда оно попало, и применяем в следующей сессии
Просто читать недостаточно, нужно попробовать. Ниже мы пройдем весь процесс от начала до конца: заставим его запомнить правило → проверим, что оно попало в файл автоматической памяти → убедимся, что оно автоматически вспомнится в следующей сессии. Все на минимальном примере, без зависимости от сложных сред.
ℹ️ Условие:
claude --version≥ v2.1.59, и автоматическая память не отключена (по умолчанию включена).
Шаг 1: Создайте игрушечный проект и запустите Claude (Mac / Linux)
mkdir memory-demo
cd memory-demo
claudeОжидаемый результат: Откроется интерфейс сессии Claude Code, внизу будет поле ввода.
Шаг 2: Заставьте его запомнить правило
В поле ввода напечатайте (используем типичную «команду сборки», которую действительно стоит запомнить):
Запомни: команда сборки для этого проекта — make build, а не npm buildОжидаемый результат: Claude ответит, что он это запомнил, и в интерфейсе промелькнет подсказка типа «Writing memory» — когда вы видите эту подсказку, это означает, что он делает запись в свою книжку.
Шаг 3: Используйте /memory, чтобы проверить, в какой файл это попало
Сразу после этого напечатайте:
/memoryОжидаемый результат: Появится интерфейс управления памятью со списком всех файлов памяти, загруженных в данный момент. Вы увидите вход в автоматическую память. Кликните по нему, и вы найдете файл MEMORY.md, в котором будет запись о только что упомянутом make build. Тот факт, что это появилось в файле = эта запись перешла из статуса «просто сказали в диалоге» в статус «сохранено в записную книжку на диске».
Если хотите проверить это напрямую из командной строки, откройте еще один терминал и введите:
cat ~/.claude/projects/*memory-demo*/memory/MEMORY.mdОжидаемый результат: В выводе вы увидите только что записанную команду сборки (имя <project> в конкретном пути будет зависеть от вашего каталога, используйте маску *). Это чистый markdown, который легко читается с первого взгляда.
Шаг 4: Проверьте, что это автоматически сработает в следующей сессии
Это ключевой шаг — смысл памяти именно в том, чтобы работать «между сессиями». Выйдите из текущей сессии:
/exitЗатем перезапустите и снова задайте ему вопрос, в котором потребуется эта память:
claudeВойдя, напечатайте:
Как собрать этот проект?Ожидаемый результат: Он прямо скажет вам использовать make build (а не станет гадать npm build) — и вы, скорее всего, увидите подсказку «Recalled memory», что означает, что он прочитал из записной книжки то, что вы сохранили в прошлый раз. Если он ответил правильно в совершенно новой сессии = память между сессиями работает корректно, поздравляем!
Шаг 5 (Опционально): Удалите эту запись и проверьте, что удаление также работает
Введя /memory, перейдите в папку автоматической памяти, удалите строку с make build и сохраните файл. В следующий раз, когда вы спросите «Как собрать проект?», он больше не будет так уверенно предлагать make build — если он запомнил что-то не так, удалите, и всё будет чисто. Именно эту власть «открыть и оторвать» дает вам /memory.
Пройдя эти пять шагов, вы собственноручно проверили всю цепочку: «записать правило → сохранить на диск → автоматически вспомнить в следующей сессии → проверить, изменить или удалить в любое время». В будущем все игры с памятью по сути будут основываться на этом механизме.
💡 Краткий итог: Заставьте его «запомнить xxx» → посмотрите подсказку «Writing memory» → проверьте через
/memoryилиcat, что это попало вMEMORY.md→ выйдите, зайдите снова, он покажет «Recalled memory» и ответит правильно → когда нужно, удалите или измените через/memory. Собственноручно пройти эту цепочку полезнее, чем выучить десять концепций.
09 Заключение
В этой статье мы разобрали «систему памяти» Claude Code с самого начала — это не одна система, а две параллельные; и лучше не запихивать туда всё подряд, а запоминать только то, что нужно.
Давайте еще раз повторим ключевые моменты:
| Что нужно понять | Вывод |
|---|---|
| Из скольких систем состоит память | Две: CLAUDE.md (вы вручную пишете правила) + автоматическая память (он сам записывает опыт) |
| Как различать эти две системы | Кто пишет, что содержит (правила или опыт), загружается полностью или имеет лимит — всё понятно из одной таблицы |
| Где хранится автоматическая память | ~/.claude/projects/<project>/memory/MEMORY.md, по git-репозиторию, локально на машине |
| Как она загружается | На старте читает только первые 200 строк / 25KB MEMORY.md, избыток отправляется в тематические файлы и читается по требованию |
| Как проверять, изменять и удалять | /memory: список загруженных файлов, открытие папки для чтения/редактирования/удаления, включение/выключение автоматической памяти |
| Что запоминать, а что нет | Три фильтра: то, что меняется, одноразовое, конфиденциальное — не записывайте ничего из этого |
Работает ли еще # | Устарело; сейчас «запомни xxx» идет в автопамять, а «добавь в CLAUDE.md» — в git |
Теперь вы должны уметь: Отличать, за что отвечают CLAUDE.md и автоматическая память, где они хранятся и как загружаются; заставлять Claude запоминать правило и проверять, в какой файл оно попало; использовать /memory для удаления неверных или устаревших записей; а также определять, нужно ли вообще записывать какую-либо информацию. Проще говоря — вы можете заставить Claude «запоминать то, что нужно запомнить, и забывать то, что нужно забыть», а не позволять ему накапливать в голове бесполезный мусор, в котором вы сами запутаетесь.
Память — это, по сути, способность Claude «пассивно запоминать факты», когда вы его поправляете, а он накапливает знания. Но то, что он может сделать для вас, выходит далеко за рамки простого запоминания.
В следующей статье мы поговорим об 26 «Agent Skills» — если память — это «пассивное запоминание фактов», то Skills — это «активная упаковка способностей»: взять набор задач, которые вы часто просите его выполнить, и упаковать их в «специализированный навык», который он может вызывать по необходимости. Если память делает так, что он «лучше вас понимает», то Skills делают так, что он «умеет больше». Небольшой вопрос для размышления: когда вы хотите «подготовить Claude заранее», как вы думаете, в каких случаях нужно использовать «запоминание правила», а в каких — «изучение навыка»?