Правила Claude Code: как писать CLAUDE.md и управлять контекстом агентного кодинга

Правила Claude Code хранятся в файлах CLAUDE.md — файлах Markdown, которые вы размещаете в репозитории проекта, домашнем каталоге или конфигурации организации. Claude читает их в начале каждого сеанса. В сочетании с правилами, привязанными к путям в .claude/rules/, файлом settings.json для разрешений и авто-памятью для изученных предпочтений, система правил даёт вам точный и постоянный контроль над поведением агента кодинга в любых задачах.

Что такое правила Claude Code?

Каждый сеанс Claude Code начинается с пустого окна контекста. Правила — это способ предварительно загрузить контекст, необходимый Claude, чтобы он не начинал с нуля — и не повторял одни и те же ошибки.

Две взаимодополняющие системы отвечают за это:

Файлы CLAUDE.md — это файлы Markdown, которые вы пишете, а Claude читает их в начале каждого сеанса. Используйте их для инструкций, которые должны применяться всегда: команды сборки, соглашения по коду, архитектурные решения, жёсткие ограничения.

Авто-память — это заметки, которые Claude пишет сам на основе исправлений и предпочтений, указанных вами во время сеансов. Они накапливаются автоматически; Claude сам решает, что стоит сохранить, и читает эти заметки в будущих сеансах.

Оба элемента загружаются в контекст при запуске сеанса, но они не являются принудительной конфигурацией. Это инструкции, которым Claude следует как контексту. Для жёсткого принуждения — например, блокировки определённой команды независимо от того, что решит Claude — вам понадобится хук PreToolUse или правило deny в settings.json. Это различие важно для автономных запусков, где требуется предсказуемое поведение, а не вероятностное соблюдение.

Расположение и область действия файлов CLAUDE.md

Claude Code загружает файлы CLAUDE.md из нескольких мест, каждое из которых охватывает свою область. Они загружаются в порядке от самой широкой области к самой конкретной:

Местоположение	Область	Для чего
~/.claude/CLAUDE.md	Все проекты на вашей машине	Личные предпочтения, глобальные привычки рабочего процесса
./CLAUDE.md (корень репозитория)	Все сеансы в этом проекте	Соглашения проекта, команды сборки, общие для команды правила
./CLAUDE.local.md (корень репозитория)	Только ваши локальные сеансы	Индивидуальные предпочтения разработчика; добавьте в .gitignore
./src/CLAUDE.md (подкаталог)	Сеансы, затрагивающие файлы в этом каталоге	Модульные правила, которые не применяются ко всему проекту

Все найденные файлы объединяются в контекст — они не переопределяют друг друга. Внутри этого объединения содержимое от корня файловой системы до вашего рабочего каталога упорядочивается так, что самое конкретное идёт последним, поэтому проектная инструкция появляется после пользовательской. Это даёт естественную специфичность: проектное правило побеждает, если конфликтует с правилом пользовательского уровня.

Вы можете импортировать дополнительные файлы с помощью ссылок @path внутри любого CLAUDE.md:

@./docs/architecture.md
@./CONTRIBUTING.md

Импортированные файлы загружаются при запуске сеанса, так же как и сам CLAUDE.md. Импорт полезен для организации, но не экономит контекст — импортированное содержимое учитывается в вашем токенном бюджете.

Для команд: фиксируйте проектный CLAUDE.md в системе контроля версий. Это гарантирует, что каждый сеанс Claude у разработчика — и любые запуски агентов в CI — начинаются с одного и того же общего контекста. Относитесь к нему как к .eslintrc или pyproject.toml.

Что помещать в CLAUDE.md

Наиболее полезно то, что иначе вам пришлось бы объяснять заново в каждом сеансе, или что новому члену команды нужно было бы знать в первый час работы.

Хорошие кандидаты:

• Команды сборки и тестирования, отличающиеся от очевидных стандартов (./scripts/test.sh --ci, а не просто npm test)
• Соглашения по коду, которые не улавливаются линтером («мы везде используем именованные экспорты; никаких экспортов по умолчанию в общих утилитах»)
• Архитектурные решения, которые не очевидны из чтения кода («каталог lib/ является общим для сервисов — не добавляйте туда логику, специфичную для сервиса»)
• Известные «подводные камни» («файл config.ts генерируется во время сборки; не редактируйте его вручную»)
• Ограничения рабочего процесса («всегда создавайте ветку перед внесением изменений; отправляйте в удалённый репозиторий перед открытием PR»)

Что следует опустить:

• Списки каталогов и деревья файлов — Claude читает их из репозитория
• Списки зависимостей — доступны из package.json, pyproject.toml и аналогичных файлов
• Прозаические описания того, что делает существующий код — Claude читает исходный код напрямую
• Недавние изменения — Claude использует git log и git diff, когда ему нужна история

Держите CLAUDE.md сфокусированным на том, что нельзя вывести из чтения кодовой базы. Файлы длиннее 200 строк потребляют больше контекста и снижают надёжность соблюдения. Команда /doctor в Claude Code проверяет зафиксированный CLAUDE.md и предлагает удалить содержимое, которое можно вывести из кода — полезный способ сократить раздутый файл.

Как писать эффективные правила

Специфичность имеет значение. Сравните:

# Расплывчато — менее последовательно
Следуйте стандартам кодинга проекта.

# Конкретно — более последовательно
- Используйте pnpm, а не npm или yarn
- Запускайте pnpm test перед каждым коммитом; не фиксируйте, если тесты не проходят
- Экспортируйте все общие типы из src/types/index.ts — не определяйте типы встроенно в файлах компонентов
- Каталог data/ доступен только для чтения в тестах; используйте тестовые фикстуры из tests/fixtures/

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

Правила, привязанные к путям, с .claude/rules/

Каталог .claude/rules/ позволяет прикреплять правила к конкретным шаблонам файлов, не загружая их в каждый сеанс. Claude обнаруживает файлы в .claude/rules/ и загружает их, когда вы работаете с соответствующими файлами.

Типичная структура для TypeScript-монорепозитория:

.claude/rules/
  api.md             # правила для src/api/** — валидация запросов, форматы ошибок
  components.md      # правила для src/components/** — типы пропсов, соглашения по стилям
  tests.md           # правила для tests/** — шаблоны фикстур, настройка моков
  database.md        # правила для migrations/ и models/ — именование миграций, шаблоны запросов

Каждый файл правил использует YAML-фронтматер с полем paths для управления загрузкой:

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

# Правила разработки API

- Все обработчики маршрутов должны проверять входные данные с помощью zod перед любой бизнес-логикой
- Возвращайте ошибки в формате `{ error: string; code: string }` — никогда не обычные строки
- Ограничение частоты запросов применяется на шлюзе; не добавляйте его внутри обработчиков

Правила без поля paths загружаются безусловно при запуске сеанса, так же как и содержимое проектного CLAUDE.md. Правила с paths загружаются только тогда, когда Claude открывает файлы, соответствующие этим шаблонам.

Это позволяет сохранить корневой CLAUDE.md проекта кратким и гарантирует, что подробные соглашения для одного уровня стека не заполняют контекст во время сеансов, сосредоточенных на другой области.

settings.json и CLAUDE.md: в чём разница

CLAUDE.md управляет тем, что Claude знает и намеревается делать. settings.json управляет тем, что Claude фактически может делать.

	CLAUDE.md	settings.json
Назначение	Инструкции и контекст	Разрешения и конфигурация
Принудительно?	Нет — Claude действует на основе этого как на руководство	Да — правила deny блокируют вызовы инструментов безусловно
Формат	Свободный Markdown	Структурированный JSON
Где находится	./CLAUDE.md, ~/.claude/CLAUDE.md	.claude/settings.json, ~/.claude/settings.json

Проектный settings.json в .claude/settings.json:

{
  "permissions": {
    "allow": [
      "Bash(pnpm test)",
      "Bash(pnpm build)",
      "Bash(git status)",
      "Bash(git diff *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force*)",
      "Bash(git reset --hard*)"
    ]
  }
}

Список allow предварительно одобряет конкретные команды, чтобы Claude мог выполнять их без запроса. Это ускоряет интерактивные сеансы для операций, которым вы доверяете. Список deny блокирует команды безусловно — независимо от того, что решит Claude, независимо от того, что написано в CLAUDE.md. Используйте deny для необратимых операций с производственными данными или инфраструктурой.

Пользовательские настройки в ~/.claude/settings.json применяются ко всем проектам. Проектные настройки в .claude/settings.json применяются только в этом репозитории. Проектные настройки имеют приоритет над пользовательскими в случае пересечения.

Авто-память: заметки Claude

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

Когда вы поправляете Claude во время сеанса — «в этом проекте мы используем Vitest, а не Jest» — он может сохранить это как заметку в ~/.claude/projects/<repo>/memory/. В следующем сеансе Claude читает эту заметку и применяет исправление без повторного объяснения.

Каталог памяти содержит:

~/.claude/projects/<repo>/memory/
  MEMORY.md          # индекс, который Claude использует для поиска других файлов; первые 200 строк загружаются каждый сеанс
  debugging.md       # шаблоны, которые Claude обнаружил при решении проблем в этом репозитории
  conventions.md     # соглашения, которые Claude усвоил из ваших исправлений

Это локально для машины и для каждого репозитория. Авто-память дополняет CLAUDE.md, а не заменяет его: CLAUDE.md предназначен для общих правил проекта команды; авто-память — для личных шаблонов, которые Claude усвоил при работе с вами.

Авто-память — это читаемый Markdown, который вы можете редактировать или удалять в любое время. Запустите /memory внутри сеанса, чтобы просматривать и редактировать файлы. Если что-то устарело или неверно, удалите это — Claude перестанет применять устаревшее правило.

Лучшие практики для агентного кодинга

Запуск Claude Code автономно — через claude -p, Agent SDK или CI-пайплайны — повышает важность вашей настройки правил. Агент может выполнить десятки вызовов инструментов без остановки, и нет интерактивного диалога, чтобы исправить недопонимания в середине запуска.

Пишите явные ограничения, а не просто предпочтения. Интерактивный Claude может попросить вас уточнить. Автономный запуск работает с тем, что находит в контексте. Если «никогда не изменять файлы миграций без создания снимка базы данных» важно, это должно быть в CLAUDE.md. Не предполагайте, что Claude выведет ограничение из структуры кодовой базы.

Используйте правила deny для всего, что трудно отменить. Предварительное одобрение Bash(pnpm build) ускоряет интерактивные сеансы и является низкорисковым. Но для автономных запусков список deny — это ваша страховочная сеть для операций, которые затрагивают производственную инфраструктуру, безвозвратно изменяют историю git или удаляют данные.

Храните проектный CLAUDE.md в системе контроля версий. Зафиксированный CLAUDE.md в корне репозитория применяется единообразно к интерактивным сеансам, CI-запускам и локальным агентам любого члена команды. Это правильное место для правил, определяющих, что означает «правильно» для вашей кодовой базы.

Используйте .claude/rules/ для доменно-специфичного содержимого. Если ваш проект имеет разные уровни — фронтенд-компоненты, бэкенд API, схема базы данных, скрипты инфраструктуры — поместите правила для каждого уровня в .claude/rules/ с привязкой к путям. Один CLAUDE.md на 400 строк, содержащий всё, сложнее для навигации Claude и стоит больше контекста за сеанс.

Переносите справочные материалы в навыки. Навыки (.claude/skills/) загружаются по требованию, а не при запуске сеанса. Длинная документация по API, многошаговые процедуры развёртывания и руководства по устранению неполадок относятся к навыкам, которые вы вызываете с помощью /deploy или /debug — а не в CLAUDE.md, где они потребляют контекст, даже когда не нужны.

Периодически просматривайте авто-память. Авто-память накапливается со временем. Команды сборки меняются, соглашения рефакторятся, шаблоны тестов сдвигаются. Устаревшая заметка в памяти, которая говорит «используйте клиент API v1», когда вы перешли на v2, вызовет тонкие ошибки в автономных запусках. Проверяйте ~/.claude/projects/<repo>/memory/ при внесении значительных изменений в структуру проекта.

Использование моделей с открытым исходным кодом с вашей настройкой правил

Контекст CLAUDE.md и .claude/rules/, которые вы создали, работают одинаково независимо от того, какая модель выполняет вывод. После того как ваши правила написаны, смена бэкенда модели сохраняет всё это — а модели с открытым исходным кодом через LLM API Novita AI являются практичным вариантом для высокообъёмной агентной работы.

Конфигурация — это одна переменная окружения:

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="<ваш-api-ключ-novita>"
export ANTHROPIC_MODEL="qwen/qwen3-coder-480b-a35b-instruct"

С ANTHROPIC_BASE_URL, указывающим на Novita AI, Claude Code отправляет все запросы на вывод на совместимый с Anthropic endpoint Novita вместо api.anthropic.com. Ваши CLAUDE.md, правила с привязкой к путям и settings.json применяются точно так же, как и раньше — уровень правил находится выше выбора модели.

Novita AI размещает модели с открытыми весами, ориентированные на кодинг, включая Qwen3-Coder, GLM-4.7, MiniMax M2.5 и DeepSeek V4. Эти модели оптимизированы для многошагового использования инструментов и вызова функций, что хорошо соответствует шаблонам вызова инструментов, которые Claude Code использует внутренне для редактирования файлов, команд оболочки и навигации по репозиторию.

Для команд, запускающих агентные задачи в масштабе — пайплайны проверки кода, автоматический рефакторинг в больших репозиториях, генерация тестов — модели с открытыми весами на Novita обычно стоят значительно меньше за миллион токенов, чем закрытые альтернативы, при этом эффективно читая и применяя ваши проектные правила.

Если вы запускаете агентов на производственной кодовой базе и хотите дополнительный уровень безопасности помимо правил deny, рассмотрите возможность сочетания LLM API Novita с Agent Sandbox от Novita. Песочница предоставляет агенту полноценную среду Linux для файловых операций и выполнения команд, изолированную от вашей хост-системы. Ваш контекст CLAUDE.md путешествует с задачей; риск выполнения остаётся локализованным.

Часто задаваемые вопросы

Что такое CLAUDE.md в Claude Code?

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

Что следует помещать в файлы правил claude rules md?

Пишите то, что иначе вам пришлось бы объяснять заново в каждом сеансе: команды сборки и тестирования, соглашения по коду, отличающиеся от стандартов фреймворка, архитектурные ограничения и известные «подводные камни» кодовой базы. Опускайте содержимое, которое Claude может вывести из самой кодовой базы — деревья файлов, списки зависимостей и описания того, что делает существующий код. Держите файлы короче 200 строк для стабильного соблюдения.

В чём разница между CLAUDE.md и settings.json в Claude Code?

CLAUDE.md — это инструкции, которым Claude следует как руководству. settings.json — это конфигурация, которую Claude Code принудительно применяет на системном уровне. Правило в CLAUDE.md формирует то, что Claude намеревается делать; запись deny в settings.json блокирует вызов инструмента безусловно. Для всего, что не должно произойти независимо от решения Claude — необратимых удалений, форсированных отправок, операций в производственной среде — используйте settings.json, а не CLAUDE.md.

Что такое каталог .claude/rules/?

.claude/rules/ содержит файлы правил, привязанные к путям, которые загружаются только тогда, когда Claude работает с файлами, соответствующими области действия правила. Это позволяет писать подробные, доменно-специфичные правила, не загружая их в каждый сеанс. Правила — это файлы Markdown с опциональным YAML-фронтматером, указывающим шаблоны glob в paths. Правила без фронтматера paths загружаются безусловно при запуске сеанса, как дополнительное содержимое CLAUDE.md.

Работает ли CLAUDE.md в CI и автоматизированных задачах claude code?

Да. Любой вызов claude -p, вызов Agent SDK или CI-пайплайн, запущенный в каталоге репозитория, загружает проектный CLAUDE.md. Это делает CLAUDE.md эффективным для обеспечения единообразного поведения как в интерактивном, так и в автоматизированном контекстах. Фиксация в системе контроля версий гарантирует, что каждый запуск — локальный и в CI — начинается с одного и того же общего контекста.

Как работает контекст claude code и как им управлять?

Контекст — это токенный бюджет текущего сеанса. Файлы CLAUDE.md, импортированные ссылки, авто-память и история диалога — всё это учитывается. Управляйте им, поддерживая CLAUDE.md кратким, используя .claude/rules/ для загрузки доменного содержимого только когда это актуально, и используя /compact для свёртывания длинных сеансов без потери непрерывности. После /compact Claude повторно читает корневой CLAUDE.md проекта с диска и автоматически внедряет его обратно в сеанс.

Как использовать лучшие практики claude code для агентного кодинга в команде?

Зафиксируйте проектный CLAUDE.md в вашем репозитории, чтобы все члены команды и CI-агенты использовали одни и те же правила. Используйте .claude/rules/ с привязкой к путям для доменно-специфичного содержимого. Добавьте правила deny в .claude/settings.json для операций, которые никогда не должны выполняться в автоматизированном контексте. Держите авто-память вне CI — она локальна для машины и для каждого разработчика; зафиксированный CLAUDE.md является источником истины для общего поведения.

Novita AI — это облачная AI-платформа, которая предоставляет разработчикам простой способ развёртывания AI-моделей через наш простой API, а также доступные и надёжные GPU-облака для создания и масштабирования.

Рекомендуемые статьи

• Документация Claude Code CLI: установка, слэш-команды и интеграция LLM API
• Claude Code SDK: создание автономных агентов с Python и TypeScript
• Создание агента кодинга с Agent Sandbox от Novita

---

Источники проверены 21 июля 2026 года: документация по памяти Claude Code, обзор функций Claude Code, LLM API Novita AI