Руководство по памяти

Память позволяет Claude сохранять контекст между сессиями и диалогами. Она существует в двух формах: автоматический синтез в claude.ai и файл CLAUDE.md на файловой системе в Claude Code.

Обзор

Память в Claude Code обеспечивает постоянный контекст, сохраняющийся между сессиями и диалогами. В отличие от временного контекстного окна, файлы памяти позволяют:

• Распространять стандарты проекта в команде
• Хранить личные предпочтения по разработке
• Задавать правила и настройки для конкретных каталогов
• Импортировать внешнюю документацию
• Хранить память под контролем версий вместе с проектом

Система памяти работает на нескольких уровнях - от глобальных личных настроек до отдельных подкаталогов, что даёт точный контроль над тем, что Claude запоминает и как применяет эти знания.

Краткий справочник команд памяти

Быстрый старт: инициализация памяти

Команда /init

Команда /init - самый быстрый способ настроить память проекта в Claude Code. Она создаёт файл CLAUDE.md с базовой документацией проекта.

Использование:

/init

Что делает:

• Создаёт новый файл CLAUDE.md в вашем проекте (обычно по пути ./CLAUDE.md или ./.claude/CLAUDE.md)
• Задаёт соглашения и правила проекта
• Закладывает основу для сохранения контекста между сессиями
• Предоставляет шаблон для документирования стандартов вашего проекта

Расширенный интерактивный режим: задайте CLAUDE_CODE_NEW_INIT=1, чтобы включить многоэтапный интерактивный сценарий, который пошагово проведёт вас через настройку проекта:

CLAUDE_CODE_NEW_INIT=1 claude
/init

Когда использовать /init:

• Старт нового проекта с Claude Code
• Внедрение командных стандартов и соглашений по написанию кода
• Создание документации по структуре кодовой базы
• Настройка иерархии памяти для совместной разработки

Пример рабочего процесса:

# In your project directory
/init

# Claude creates CLAUDE.md with structure like:
# Project Configuration
## Project Overview
- Name: Your Project
- Tech Stack: [Your technologies]
- Team Size: [Number of developers]

## Development Standards
- Code style preferences
- Testing requirements
- Git workflow conventions

Быстрое обновление памяти

Примечание: сокращение # для добавления записей в память по ходу диалога больше не поддерживается. Используйте /memory, чтобы редактировать файлы памяти напрямую, либо просто попросите Claude что-то запомнить (например, «запомни, что мы всегда используем TypeScript strict mode»).

Рекомендуемые способы добавить информацию в память:

Вариант 1: команда /memory

/memory

Открывает файлы памяти в системном редакторе для прямого редактирования.

Вариант 2: запрос в диалоге

Remember that we always use TypeScript strict mode in this project.
Please add to memory: prefer async/await over promise chains.

Claude обновит соответствующий файл CLAUDE.md согласно вашему запросу.

Историческая справка (больше не поддерживается):

Ранее сокращение с префиксом # позволяло добавлять правила прямо на месте:

# Always use TypeScript strict mode in this project  ← no longer works

Если вы использовали этот паттерн, перейдите на команду /memory или запросы в диалоге.

Команда /memory

Команда /memory предоставляет прямой доступ к редактированию файлов памяти CLAUDE.md прямо из сессии Claude Code. Она открывает файлы памяти в системном редакторе для полноценного редактирования. При открытии файла в GUI-редакторе сессия больше не блокируется на время работы с файлом, так что можно продолжать работу параллельно (v2.1.216); терминальные редакторы вроде Vim по-прежнему занимают терминал до выхода из них.

Использование:

/memory

Что делает команда:

• Открывает файлы памяти в редакторе, заданном в системе по умолчанию
• Позволяет вносить масштабные дополнения, изменения и проводить реорганизацию
• Даёт прямой доступ ко всем файлам памяти в иерархии
• Позволяет управлять постоянным контекстом между сессиями

Когда использовать /memory:

• Просмотр текущего содержимого памяти
• Масштабное обновление стандартов проекта
• Реорганизация структуры памяти
• Добавление подробной документации или рекомендаций
• Поддержка и обновление памяти по мере развития проекта

Сравнение: /memory и /init

# Open memory for editing
/memory

# Claude presents options:
# 1. Managed Policy Memory
# 2. Project Memory (./CLAUDE.md)
# 3. User Memory (~/.claude/CLAUDE.md)
# 4. Local Project Memory

# Choose option 2 (Project Memory)
# Your default editor opens with ./CLAUDE.md content

# Make changes, save, and close editor
# Claude automatically reloads the updated memory

Использование импортов памяти:

Файлы CLAUDE.md поддерживают синтаксис @path/to/file для подключения внешнего содержимого:

# Project Documentation
See @README.md for project overview
See @package.json for available npm commands
See @docs/architecture.md for system design

# Import from home directory using absolute path
@~/.claude/my-project-instructions.md

Возможности импорта:

• Поддерживаются как относительные, так и абсолютные пути (например, @docs/api.md или @~/.claude/my-project-instructions.md)
• Поддерживается рекурсивный импорт с максимальной глубиной 4 уровня
• При первом импорте из внешнего расположения запрашивается подтверждение - в целях безопасности
• Директивы импорта не обрабатываются внутри inline-кода и блоков кода в Markdown (поэтому их можно безопасно приводить в примерах)
• Помогает избежать дублирования за счёт ссылок на существующую документацию
• Автоматически подключает указанное содержимое в контекст Claude

Архитектура памяти

Память в Claude Code построена по иерархическому принципу, где разные области видимости решают разные задачи. В отличие от 24-часового цикла синтеза в Claude Web/Desktop (см. Память в Claude Web/Desktop ниже), в Claude Code есть две системы памяти: обе загружаются в начале каждой сессии и обновляются непрерывно, а не по таймеру:

Иерархия памяти в Claude Code

У Claude Code есть две взаимодополняющие системы памяти, и обе загружаются в начале каждого разговора: файлы CLAUDE.md (инструкции, которые пишете вы) и auto memory (заметки, которые Claude ведёт сам). Файлы CLAUDE.md склеиваются в контексте, а не переопределяют друг друга - это не жёсткая цепочка приоритетов, в которой более высокий уровень вытесняет более низкий. Файлы .claude/rules/*.md - это отдельный, но смежный механизм для инструкций, привязанных к теме или пути.

Расположения файлов CLAUDE.md в порядке загрузки (от самой широкой области действия к самой узкой):

Организации также могут размещать управляемое содержимое CLAUDE.md прямо в managed-settings.json через ключ claudeMd, не разворачивая отдельный файл. Это учитывается только в managed/policy settings - задание claudeMd в пользовательских или проектных настройках не даёт никакого эффекта.

.claude/rules/*.md - модульные тематические инструкции, при необходимости привязываемые к путям файлов через поле paths во frontmatter. Правила без поля paths загружаются безусловно с тем же приоритетом, что и .claude/CLAUDE.md; правила с привязкой к путям загружаются по требованию, когда Claude читает подходящий под шаблон файл. Правила уровня пользователя (~/.claude/rules/) загружаются раньше проектных.

Auto memory (~/.claude/projects/<project>/memory/) - это отдельная система: собственные заметки Claude, а не содержимое CLAUDE.md, и они не входят в описанный выше порядок конкатенации. См. раздел Auto Memory ниже.

Примечание: CLAUDE.local.md полностью поддерживается и описан в официальной документации. Он позволяет хранить личные настройки для конкретного проекта, которые не коммитятся в систему контроля версий. Добавьте CLAUDE.local.md в свой .gitignore.

Как работает обнаружение memory:

Все показанные файлы объединяются в один общий контекст, а не выбираются через override - более поздние блоки просто идут дальше по контексту, а не «вместо» более ранних.

Исключение файлов CLAUDE.md с помощью claudeMdExcludes

В крупных монорепозиториях часть файлов CLAUDE.md может быть нерелевантна текущей задаче. Настройка claudeMdExcludes позволяет исключить конкретные файлы CLAUDE.md, чтобы они не загружались в контекст:

// In ~/.claude/settings.json or .claude/settings.json
{
  "claudeMdExcludes": [
    "packages/legacy-app/CLAUDE.md",
    "vendors/**/CLAUDE.md"
  ]
}

Шаблоны сопоставляются с путями относительно корня проекта. Это особенно полезно в следующих случаях:

• Монорепозитории с множеством подпроектов, из которых актуальны лишь некоторые
• Репозитории, содержащие вендорные или сторонние файлы CLAUDE.md
• Уменьшение шума в контекстном окне Claude за счёт исключения устаревших или не относящихся к делу инструкций

Иерархия файлов настроек

Настройки Claude Code (включая autoMemoryDirectory, claudeMdExcludes и другие параметры) разрешаются по приоритету - в отличие от рассмотренных выше файлов CLAUDE.md, настройки действительно переопределяют друг друга, а не объединяются. Если одна и та же настройка задана в нескольких областях, побеждает значение с более высокого уровня:

Правила разрешений (allow/ask/deny) ведут себя иначе, чем остальные настройки: они объединяются между областями действия, а не переопределяются более высоким уровнем.

Платформозависимая конфигурация (v2.1.51+):

Настройки также можно задавать через:

• macOS: property list (plist) файлы
• Windows: реестр Windows

Эти нативные для платформ механизмы считываются наряду с JSON-файлами настроек и подчиняются тем же правилам приоритета.

Примечание (v2.1.119): изменения через /config теперь сохраняются в ~/.claude/settings.json. Значения, записанные через /config, участвуют в описанной выше цепочке приоритетов policy/local/project - они больше не ограничены текущей сессией. Используйте /config для интерактивного редактирования, а для скриптовой или управляемой конфигурации правьте файлы settings.json напрямую.

Настройки хранения и очистки

// ~/.claude/settings.json
{
  "cleanupPeriodDays": 14
}

Настройки атрибуции, авторства и URL пул-реквеста

// ~/.claude/settings.json
{
  "attribution": {
    "commit": false,
    "pr": true
  },
  "voice": {
    "enabled": true
  },
  "prUrlTemplate": "https://gitlab.internal/{{owner}}/{{repo}}/-/merge_requests/{{number}}"
}

Устаревшие имена настроек

Перечисленные ниже устаревшие ключи настроек всё ещё работают, но их использование не рекомендуется. Используйте указанные выше замены.

Модульная система правил

Организуйте правила по путям с помощью структуры каталогов .claude/rules/. Правила можно задавать как на уровне проекта, так и на уровне пользователя:

your-project/
├── .claude/
│   ├── CLAUDE.md
│   └── rules/
│       ├── code-style.md
│       ├── testing.md
│       ├── security.md
│       └── api/                  # Subdirectories supported
│           ├── conventions.md
│           └── validation.md

~/.claude/
├── CLAUDE.md
└── rules/                        # User-level rules (all projects)
    ├── personal-style.md
    └── preferred-patterns.md

Правила загружаются рекурсивно из директории rules/, включая все вложенные поддиректории. Правила уровня пользователя из ~/.claude/rules/ загружаются раньше правил уровня проекта, что позволяет задавать персональные настройки по умолчанию, которые проект может переопределить.

Правила для конкретных путей через YAML frontmatter

Задавайте правила, которые применяются только к определённым путям файлов:

---
paths: src/api/**/*.ts
---

# API Development Rules

- All API endpoints must include input validation
- Use Zod for schema validation
- Document all parameters and response types
- Include error handling for all operations

Примеры glob-паттернов:

• **/*.ts - все файлы TypeScript
• src/**/* - все файлы внутри src/
• src/**/*.{ts,tsx} - несколько расширений
• {src,lib}/**/*.ts, tests/**/*.test.ts - несколько паттернов одновременно

Подкаталоги и симлинки

Правила в .claude/rules/ поддерживают два способа организации:

• Подкаталоги: правила обнаруживаются рекурсивно, поэтому их можно раскладывать по тематическим папкам (например, rules/api/, rules/testing/, rules/security/).
• Симлинки: поддерживаются симлинки для совместного использования правил в нескольких проектах. Например, можно создать симлинк на общий файл правил из центрального хранилища в каталог .claude/rules/ каждого проекта.

Таблица расположений памяти

Файлы CLAUDE.md и правила склеиваются в контексте, а не выбираются по принципу строгого переопределения - «порядок загрузки» ниже означает где именно в контексте они появляются, а не какой из них имеет приоритет. Auto memory - это отдельный механизм со своим местом хранения.

Жизненный цикл обновления памяти

Вот как обновления памяти распространяются между сессиями Claude Code:

Автоматическая память

Автоматическая память - это постоянный каталог, в который Claude автоматически записывает выводы, паттерны и наблюдения по мере работы над вашим проектом. В отличие от файлов CLAUDE.md, которые вы ведёте вручную, автоматическая память заполняется самим Claude в ходе сессий.

Как работает автоматическая память

• Расположение: ~/.claude/projects/<project>/memory/
• Точка входа: MEMORY.md - основной файл в каталоге автоматической памяти
• Тематические файлы: дополнительные файлы по конкретным темам (например, debugging.md, api-conventions.md)
• Логика загрузки: при старте сессии в контекст загружаются первые 200 строк MEMORY.md (или первые 25 КБ - в зависимости от того, что наступит раньше). Тематические файлы загружаются по мере необходимости, а не при запуске.
• Чтение/запись: Claude читает и обновляет файлы памяти в ходе сессии, обнаруживая паттерны и специфичные для проекта знания
• Frontmatter: в файлах, начинающихся с YAML-frontmatter, появляется поле modified - временна́я метка в формате ISO 8601, которую Claude Code обновляет при каждой записи файла (v2.1.214)

Архитектура автоматической памяти

Структура каталога Auto Memory

~/.claude/projects/<project>/memory/
├── MEMORY.md              # Entrypoint (first 200 lines / 25KB loaded at startup)
├── debugging.md           # Topic file (loaded on demand)
├── api-conventions.md     # Topic file (loaded on demand)
└── testing-patterns.md    # Topic file (loaded on demand)

Требования к версии

Для работы автопамяти необходим Claude Code v2.1.59 или новее. Если у вас установлена более ранняя версия, сначала обновите её:

npm install -g @anthropic-ai/claude-code@latest

Включение и отключение автоматической памяти

Автоматическая память включена по умолчанию. Управляет ею параметр autoMemoryEnabled (по умолчанию true); при значении false Claude не читает из каталога автоматической памяти и не пишет в него. Также её можно переключать командой /memory прямо во время сессии.

{
  "autoMemoryEnabled": false
}

Чтобы отключить эту функцию через переменную окружения, задайте CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Значение 0, наоборот, принудительно включает auto memory, даже если режим --bare или параметр autoMemoryEnabled: false в обычной ситуации отключили бы её.

Пользовательский каталог для Auto Memory

По умолчанию auto memory хранится в ~/.claude/projects/<project>/memory/. Изменить это расположение можно с помощью настройки autoMemoryDirectory (доступна начиная с v2.1.74):

// In ~/.claude/settings.json or .claude/settings.local.json (user/local settings only)
{
  "autoMemoryDirectory": "/path/to/custom/memory/directory"
}

Примечание: autoMemoryDirectory можно задать только в пользовательских настройках (~/.claude/settings.json) или локальных настройках (.claude/settings.local.json), но не в настройках проекта или управляемой политики.

Это удобно, когда нужно:

• Хранить auto memory в общем или синхронизируемом расположении
• Отделить auto memory от стандартной директории конфигурации Claude
• Использовать путь, специфичный для проекта, вне стандартной иерархии

Общий доступ для worktree и репозитория

Все worktree и поддиректории в пределах одного git-репозитория используют общую директорию auto memory. Это значит, что при переключении между worktree или работе в разных поддиректориях одного репозитория чтение и запись будут выполняться в одни и те же файлы памяти.

Память субагентов

Субагенты (запускаемые через такие инструменты, как Task, или через параллельное выполнение) могут иметь собственный контекст памяти. Чтобы указать, какие области памяти загружать, используйте поле memory во frontmatter определения субагента:

memory: user      # Load user-level memory only
memory: project   # Load project-level memory only
memory: local     # Load local memory only

Это позволяет субагентам работать в сфокусированном контексте, не наследуя всю иерархию памяти.

Примечание: Субагенты также могут вести собственную auto memory. Подробнее см. в официальной документации по памяти субагентов.

Управление auto memory

Поведением auto memory можно управлять через переменную окружения CLAUDE_CODE_DISABLE_AUTO_MEMORY:

# Disable auto memory for a session
CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

# Force auto memory on explicitly
CLAUDE_CODE_DISABLE_AUTO_MEMORY=0 claude

Дополнительные каталоги через --add-dir

Флаг --add-dir позволяет Claude Code загружать файлы CLAUDE.md из дополнительных каталогов помимо текущего рабочего. Это удобно для монорепозиториев или проектов с несколькими подпроектами, когда требуется контекст из других каталогов.

Чтобы включить эту возможность, задайте переменную окружения:

CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1

Затем запустите Claude Code с флагом:

claude --add-dir /path/to/other/project

Claude загрузит CLAUDE.md из указанного дополнительного каталога вместе с файлами памяти из текущего рабочего каталога.

Практические примеры

Пример 1: Структура памяти проекта

Файл: ./CLAUDE.md

# Project Configuration

## Project Overview
- **Name**: E-commerce Platform
- **Tech Stack**: Node.js, PostgreSQL, React 18, Docker
- **Team Size**: 5 developers
- **Deadline**: Q4 2025

## Architecture
@docs/architecture.md
@docs/api-standards.md
@docs/database-schema.md

## Development Standards

### Code Style
- Use Prettier for formatting
- Use ESLint with airbnb config
- Maximum line length: 100 characters
- Use 2-space indentation

### Naming Conventions
- **Files**: kebab-case (user-controller.js)
- **Classes**: PascalCase (UserService)
- **Functions/Variables**: camelCase (getUserById)
- **Constants**: UPPER_SNAKE_CASE (API_BASE_URL)
- **Database Tables**: snake_case (user_accounts)

### Git Workflow
- Branch names: `feature/description` or `fix/description`
- Commit messages: Follow conventional commits
- PR required before merge
- All CI/CD checks must pass
- Minimum 1 approval required

### Testing Requirements
- Minimum 80% code coverage
- All critical paths must have tests
- Use Jest for unit tests
- Use Cypress for E2E tests
- Test filenames: `*.test.ts` or `*.spec.ts`

### API Standards
- RESTful endpoints only
- JSON request/response
- Use HTTP status codes correctly
- Version API endpoints: `/api/v1/`
- Document all endpoints with examples

### Database
- Use migrations for schema changes
- Never hardcode credentials
- Use connection pooling
- Enable query logging in development
- Regular backups required

### Deployment
- Docker-based deployment
- Kubernetes orchestration
- Blue-green deployment strategy
- Automatic rollback on failure
- Database migrations run before deploy

## Common Commands

| Command | Purpose |
|---------|---------|
| `npm run dev` | Start development server |
| `npm test` | Run test suite |
| `npm run lint` | Check code style |
| `npm run build` | Build for production |
| `npm run migrate` | Run database migrations |

## Team Contacts
- Tech Lead: Sarah Chen (@sarah.chen)
- Product Manager: Mike Johnson (@mike.j)
- DevOps: Alex Kim (@alex.k)

## Known Issues & Workarounds
- PostgreSQL connection pooling limited to 20 during peak hours
- Workaround: Implement query queuing
- Safari 14 compatibility issues with async generators
- Workaround: Use Babel transpiler

## Related Projects
- Analytics Dashboard: `/projects/analytics`
- Mobile App: `/projects/mobile`
- Admin Panel: `/projects/admin`

Пример 2: Память для конкретного каталога

Файл: ./src/api/CLAUDE.md

# API Module Standards

This file overrides root CLAUDE.md for everything in /src/api/

## API-Specific Standards

### Request Validation
- Use Zod for schema validation
- Always validate input
- Return 400 with validation errors
- Include field-level error details

### Authentication
- All endpoints require JWT token
- Token in Authorization header
- Token expires after 24 hours
- Implement refresh token mechanism

### Response Format

All responses must follow this structure:

```json
Текущая дата: вторник, 4 августа 2026 г.

<query>
{
  &quot;success&quot;: true,
  &quot;data&quot;: { /* actual data */ },
  &quot;timestamp&quot;: &quot;2025-11-06T10:30:00Z&quot;,
  &quot;version&quot;: &quot;1.0&quot;
}
</query>
```

Error responses:
```json
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Сообщение пользователю",
    "details": { /* ошибки полей */ }
  },
  "timestamp": "2025-11-06T10:30:00Z"
}
```

### Pagination
- Use cursor-based pagination (not offset)
- Include `hasMore` boolean
- Limit max page size to 100
- Default page size: 20

### Rate Limiting
- 1000 requests per hour for authenticated users
- 100 requests per hour for public endpoints
- Return 429 when exceeded
- Include retry-after header

### Caching
- Use Redis for session caching
- Cache duration: 5 minutes default
- Invalidate on write operations
- Tag cache keys with resource type

Пример 3: Персональная память

Файл: ~/.claude/CLAUDE.md

# My Development Preferences

## About Me
- **Experience Level**: 8 years full-stack development
- **Preferred Languages**: TypeScript, Python
- **Communication Style**: Direct, with examples
- **Learning Style**: Visual diagrams with code

## Code Preferences

### Error Handling
I prefer explicit error handling with try-catch blocks and meaningful error messages.
Avoid generic errors. Always log errors for debugging.

### Comments
Use comments for WHY, not WHAT. Code should be self-documenting.
Comments should explain business logic or non-obvious decisions.

### Testing
I prefer TDD (test-driven development).
Write tests first, then implementation.
Focus on behavior, not implementation details.

### Architecture
I prefer modular, loosely-coupled design.
Use dependency injection for testability.
Separate concerns (Controllers, Services, Repositories).

## Debugging Preferences
- Use console.log with prefix: `[DEBUG]`
- Include context: function name, relevant variables
- Use stack traces when available
- Always include timestamps in logs

## Communication
- Explain complex concepts with diagrams
- Show concrete examples before explaining theory
- Include before/after code snippets
- Summarize key points at the end

## Project Organization
I organize my projects as:

   project/
   ├── src/
   │   ├── api/
   │   ├── services/
   │   ├── models/
   │   └── utils/
   ├── tests/
   ├── docs/
   └── docker/

## Tooling
- **IDE**: VS Code with vim keybindings
- **Terminal**: Zsh with Oh-My-Zsh
- **Format**: Prettier (100 char line length)
- **Linter**: ESLint with airbnb config
- **Test Framework**: Jest with React Testing Library

Мой тест Прошу Claude сохранить новое правило

Claude не сохранил правило, так как у меня нигде не было файла Claude.md. Тогда я попросил Claude подтвердить расположение.

Пример 4: обновление памяти во время сессии

Вы можете добавлять новые правила в память прямо во время активной сессии Claude Code, просто попросив об этом в диалоге:

User: Remember that I prefer using React hooks instead of class components
     for all new components.

Claude: I'm adding that to your memory. Which memory file should this go in?
        1. Project memory (./CLAUDE.md)
        2. Personal memory (~/.claude/CLAUDE.md)

User: Project memory

Claude: ✅ Memory saved!

Added to ./CLAUDE.md:
---

### Component Development
- Use functional components with React Hooks
- Prefer hooks over class components
- Custom hooks for reusable logic
- Use useCallback for event handlers
- Use useMemo for expensive computations

Либо используйте /memory, чтобы редактировать файлы памяти напрямую - это удобно для масштабных обновлений или реорганизации.

Советы по добавлению записей в память

• Формулируйте правила конкретно и в виде выполнимых указаний
• Группируйте связанные правила под общим заголовком раздела
• Обновляйте существующие разделы, а не дублируйте содержимое
• Выбирайте подходящую область памяти (проектную или личную)

Сравнение возможностей памяти

Память в Claude Web/Desktop

Хронология синтеза памяти

Пример сводки памяти:

## Claude's Memory of User

### Professional Background
- Senior full-stack developer with 8 years experience
- Focus on TypeScript/Node.js backends and React frontends
- Active open source contributor
- Interested in AI and machine learning

### Project Context
- Currently building e-commerce platform
- Tech stack: Node.js, PostgreSQL, React 18, Docker
- Working with team of 5 developers
- Using CI/CD and blue-green deployments

### Communication Preferences
- Prefers direct, concise explanations
- Likes visual diagrams and examples
- Appreciates code snippets
- Explains business logic in comments

### Current Goals
- Improve API performance
- Increase test coverage to 90%
- Implement caching strategy
- Document architecture

Лучшие практики

Что делать - что включать

• Будьте конкретны и подробны: используйте чёткие, детальные инструкции вместо размытых рекомендаций

  • ✅ Хорошо: «Используйте отступ в 2 пробела для всех файлов JavaScript»
  • ❌ Избегайте: «Следуйте лучшим практикам»

• Соблюдайте структуру: организуйте файлы памяти с помощью понятных markdown-разделов и заголовков

• Используйте подходящие уровни иерархии:

  • Managed policy: политики уровня компании, стандарты безопасности, требования compliance
  • Память проекта: командные стандарты, архитектура, соглашения по оформлению кода (коммитятся в git)
  • Память пользователя: личные предпочтения, стиль общения, выбор инструментов
  • Память директории: правила и переопределения, специфичные для конкретного модуля

• Используйте импорты: применяйте синтаксис @path/to/file, чтобы ссылаться на существующую документацию

  • Поддерживается максимальная глубина 4 уровня для рекурсивных импортов
  • Позволяет избежать дублирования между файлами памяти
  • Пример: See @README.md for project overview

• Документируйте часто используемые команды: записывайте команды, которые вы применяете регулярно, - это экономит время

• Держите память проекта под контролем версий: коммитьте файлы CLAUDE.md уровня проекта в git на пользу всей команде

• Периодически пересматривайте: регулярно обновляйте память по мере развития проекта и изменения требований

• Приводите конкретные примеры: включайте фрагменты кода и конкретные сценарии

Чего не делать - чего избегать

• Не храните секреты: никогда не включайте API-ключи, пароли, токены или учётные данные

• Не включайте чувствительные данные: никаких PII, приватной информации или коммерческих тайн

• Не дублируйте содержимое: вместо этого используйте импорты (@path) для ссылок на существующую документацию

• Не будьте расплывчаты: избегайте общих формулировок вроде «следуйте лучшим практикам» или «пишите хороший код»

• Не делайте файл слишком длинным: ориентируйтесь на менее 200 строк в CLAUDE.md. Более длинные файлы всё равно загружаются целиком, но следование инструкциям падает - см. Как сохранять CLAUDE.md компактным ниже

• Не переусердствуйте с организацией: используйте иерархию продуманно; не плодите избыточные переопределения по подкаталогам

• Не забывайте обновлять: устаревшая память приводит к путанице и следованию неактуальным практикам

• Не превышайте лимиты вложенности: импорты памяти поддерживают максимум 4 уровня вложенности

Как сохранять CLAUDE.md компактным

Текущая рекомендация Anthropic прямо противоположна принципу «положите всё в CLAUDE.md». Файл загружается в каждую сессию, поэтому каждая добавленная строка конкурирует за внимание модели в задачах, к которым она не имеет никакого отношения.

Практическое правило: держите CLAUDE.md в пределах 200 строк. Более длинные файлы всё равно загружаются целиком, но по мере роста файла качество следования инструкциям снижается.

Когда файл начинает разрастаться, выносите содержимое наружу, а не сокращайте текст:

Примечание: импорты @path помогают структурировать большой CLAUDE.md, но не экономят контекст - импортируемые файлы всё равно подтягиваются при загрузке. Реально сокращает объём загружаемого именно разбиение на правила, привязанные к путям.

/doctor (v2.1.206+) анализирует вашу конфигурацию и предлагает, что урезать, когда CLAUDE.md разросся настолько, что перестал приносить пользу.

Не пишите напоминания о проверках

Прежние рекомендации поощряли фразы вроде «всегда запускай тесты, прежде чем сказать, что всё готово» или «перепроверь свою работу». На Claude Opus 5 и Fable 5 это теперь приводит к чрезмерным проверкам - Claude заново перепроверяет и без того корректную работу, впустую тратя ходы и токены.

В поколении Claude 5 Anthropic удалила более 80% собственного системного промпта Claude Code без какой-либо измеримой деградации. Тот же принцип применим и к вашему CLAUDE.md: лучше сформулировать цель и дать Claude действовать по своему усмотрению, чем перечислять проверки, которые он обязан выполнить.

Удалите напоминания о проверках из существующих файлов CLAUDE.md, рассчитанных на Opus 5 или Fable 5. Оставляйте только действительно неочевидные требования проекта - «integration tests need Docker running» - это информация, а не напоминание.

Советы по управлению памятью

Выбирайте подходящий уровень памяти:

1. Для одиночных правил: используйте /memory, чтобы открыть редактор, либо просто попросите в чате
2. Для нескольких изменений: используйте /memory, чтобы открыть редактор
3. Для первоначальной настройки: используйте /init, чтобы создать шаблон

Рекомендации по импорту:

# Good: Reference existing docs
@README.md
@docs/architecture.md
@package.json

# Avoid: Copying content that exists elsewhere
# Instead of copying README content into CLAUDE.md, just import it

Инструкция по установке

Настройка памяти проекта

Способ 1: команда /init (рекомендуется)

Самый быстрый способ настроить память проекта:

1. Перейдите в каталог проекта:

   bashКопировать

   cd /path/to/your/project
   

2. Выполните команду init в Claude Code:

   bashКопировать

   /init
   

3. Claude создаст файл CLAUDE.md и заполнит его шаблонной структурой

4. Отредактируйте сгенерированный файл под нужды вашего проекта

5. Закоммитьте изменения в git:

   bashКопировать

   git add CLAUDE.md
   git commit -m "Initialize project memory with /init"
   

Способ 2: создание вручную

Если вы предпочитаете ручную настройку:

1. Создайте CLAUDE.md в корне проекта:

   bashКопировать

   cd /path/to/your/project
   touch CLAUDE.md
   

2. Добавьте стандарты проекта:

   bashКопировать

   cat > CLAUDE.md << 'EOF'
   # Project Configuration
   
   ## Project Overview
   - **Name**: Your Project Name
   - **Tech Stack**: List your technologies
   - **Team Size**: Number of developers
   
   ## Development Standards
   - Your coding standards
   - Naming conventions
   - Testing requirements
   EOF
   

3. Закоммитьте изменения в git:

   bashКопировать

   git add CLAUDE.md
   git commit -m "Add project memory configuration"
   

Настройка персональной памяти

1. Создайте каталог ~/.claude:

   bashКопировать

   mkdir -p ~/.claude
   

2. Создайте персональный CLAUDE.md:

   bashКопировать

   touch ~/.claude/CLAUDE.md
   

3. Опишите свои предпочтения:

   bashКопировать

   cat > ~/.claude/CLAUDE.md << 'EOF'
   # My Development Preferences
   
   ## About Me
   - Experience Level: [Your level]
   - Preferred Languages: [Your languages]
   - Communication Style: [Your style]
   
   ## Code Preferences
   - [Your preferences]
   EOF
   

Настройка памяти для отдельного каталога

1. Создайте память для конкретного каталога:

   bashКопировать

   mkdir -p /path/to/directory/.claude
   touch /path/to/directory/CLAUDE.md
   

2. Задайте правила для этого каталога:

   bashКопировать

   cat > /path/to/directory/CLAUDE.md << 'EOF'
   # [Directory Name] Standards
   
   This file overrides root CLAUDE.md for this directory.
   
   ## [Specific Standards]
   EOF
   

3. Закоммитьте в систему контроля версий:

   bashКопировать

   git add /path/to/directory/CLAUDE.md
   git commit -m "Add [directory] memory configuration"
   

Проверка настройки

1. Проверьте, что файлы памяти на месте:

   bashКопировать

   # Project root memory
   ls -la ./CLAUDE.md
   
   # Personal memory
   ls -la ~/.claude/CLAUDE.md
   

2. Claude Code автоматически загрузит эти файлы при старте сессии

3. Проверьте работу, запустив новую сессию Claude Code в проекте

Официальная документация

Актуальную информацию смотрите в официальной документации Claude Code:

• Документация по памяти - полный справочник по системе памяти
• Справочник slash-команд - все встроенные команды, включая /init и /memory
• Справочник CLI - документация по интерфейсу командной строки

Ключевые технические детали из официальной документации

Загрузка памяти:

• Все файлы памяти загружаются автоматически при запуске Claude Code
• Claude поднимается вверх от текущего рабочего каталога в поисках файлов CLAUDE.md
• Файлы во вложенных каталогах обнаруживаются и подгружаются по мере обращения к этим каталогам

Синтаксис импортов:

• Для подключения внешнего содержимого используйте @path/to/file (например, @~/.claude/my-project-instructions.md)
• Поддерживаются как относительные, так и абсолютные пути (относительные разрешаются относительно файла с импортом, а не текущего рабочего каталога)
• Поддерживаются рекурсивные импорты с максимальной глубиной до 4 уровней
• При первом внешнем импорте появляется диалог подтверждения
• Импорты не обрабатываются внутри inline-кода и блоков кода Markdown
• Содержимое по ссылке автоматически включается в контекст Claude

Порядок загрузки CLAUDE.md (файлы объединяются в общий контекст, а не жёстко переопределяют друг друга - см. раздел Иерархия памяти в Claude Code выше):

1. Managed Policy (загружается первой)
2. Правила уровня пользователя (~/.claude/rules/)
3. Пользовательская память
4. Правила проекта (.claude/rules/)
5. Память проекта
6. Локальная память проекта (загружается последней)

Auto Memory - это отдельный механизм (~/.claude/projects/<project>/memory/), не входящий в описанный порядок конкатенации.

Ссылки на связанные концепции

Точки интеграции

• Протокол MCP - доступ к актуальным данным в дополнение к памяти
• Slash-команды - быстрые команды в рамках сессии
• Skills - автоматизированные сценарии с учётом памяти

Смежные возможности Claude

• Claude Web Memory - автоматический синтез
• Официальная документация по памяти - документация Anthropic

Последнее обновление: 4 августа 2026 г. Версия Claude Code: 2.1.220 Источники:

• https://code.claude.com/docs/en/memory Совместимые модели: Claude Fable 5, Claude Opus 5, Claude Sonnet 5, Claude Sonnet 4.6, Claude Opus 4.8, Claude Haiku 4.5