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

Память позволяет 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.

Как работает обнаружение памяти:

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

Исключение файлов 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/)
• Символические ссылки: symlink'и поддерживаются для совместного использования правил в нескольких проектах. Например, можно создать символическую ссылку на общий файл правил из централизованного хранилища в каталог .claude/rules/ каждого проекта

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

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

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

Ниже показано, как обновления памяти распространяются между сессиями 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 supplements root CLAUDE.md for everything in /src/api/. Memory files are
concatenated, not overridden - the root CLAUDE.md still applies, and Claude Code
loads this file on demand when it reads files in this subtree.

## 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
{
  "success": true,
  "data": { /* actual data */ },
  "timestamp": "2025-11-06T10:30:00Z",
  "version": "1.0"
}
```

Error responses:
```json
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "User 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: корпоративные политики, стандарты безопасности, требования комплаенса
  • Память проекта: командные стандарты, архитектура, соглашения по коду (коммитятся в 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 заново проверяет уже корректный результат, впустую расходуя ходы и токены.

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

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

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

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

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 supplements root CLAUDE.md for this directory. Memory files are
   concatenated, not overridden - Claude Code loads this file on demand when it
   reads files in 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

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

• 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