Claude Code — команды, настройки, флаги

Привет!

Это справочник. Не рассказ о том, как правильно работать с агентом — про это у меня есть отдельная статья, — а перечень: что можно набрать, что можно написать в настройках, что из этого что делает и как это выглядит на практике.

Актуальность: август 2026. Списки команд, ключей и флагов сняты со сборки 2.1.251, а то, что можно было проверить запуском, проверено на 2.1.252. Для технической статьи версия важнее обычного: между соседними сборками команды исчезают, меняют имена и меняются местами. Если у вас другая версия, /help и claude --help всегда правы, а я — только на момент написания.

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

Три места, куда вводят команды

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

Слэш-команды набираются внутри работающей сессии, с / в начале строки. Они управляют разговором: сменить модель, сжать контекст, откатить правки, запустить ревью. В терминале они не работают.

settings.json — файл на диске. Он задаёт, каким Claude Code запустится: какая модель, какие права у инструментов, какие хуки, что показывать в строке состояния. Значительная часть настроек существует только здесь и не имеет команды-эквивалента.

Терминальные команды claude вводятся в обычной оболочке, до или помимо сессии: установка, авторизация, MCP-серверы, плагины, фоновые агенты, неинтерактивный запуск для скриптов.

Разделение не декоративное. Половина вопросов «почему не срабатывает» объясняется тем, что человек написал /model в терминале или --effort в файле настроек. Есть, впрочем, и приятное исключение: в неинтерактивном режиме claude -p слэш-команды в тексте промпта работают — про это ниже отдельно.

Слэш-команды

Набираются внутри работающей сессии, с / в начале строки. У каждой команды ниже собрано всё сразу: аргументы со всеми значениями, тонкости и примеры.

Пометки: [Навык] — встроенный навык, то есть готовый промпт-сценарий; [Воркфлоу] — встроенный мульти-агентный воркфлоу; [сверх тарифа] — платится кредитами отдельно от подписки; [не на всех тарифах] — доступность зависит от тарифа, организации или провайдера; [нет в документации] — в сборке есть, а в публичных источниках не описано.

Про примеры. В блоках — то, что реально набирают, с настоящими аргументами, а не голое имя команды. Вывод показан там, где его удалось взять с работающей сборки или из официальной документации; он на английском, потому что так и печатается. Где достоверного вывода нет — его нет и здесь, а что появится на экране и между чем придётся выбирать, сказано словами в описании команды. Придуманных экранов в статье не будет.

Команды, которые в этой сборке выключены или убраны совсем, своих разделов не имеют — они собраны таблицей в конце этого раздела.

Сессии и разговор

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

/clear [имя]

Начать новый разговор с чистым контекстом. Алиасы: /reset, /new. За ней тянутся при переходе к другой задаче: старый контекст перестаёт помогать и начинает мешать — модель продолжает тащить в ответы подробности прежнего дела.

Старый разговор не удаляется — он остаётся на диске и открывается через /resume. Необязательный аргумент подписывает его в списке: без подписи вы через неделю будете смотреть на десяток безымянных строк.

Если очистили случайно, в том же процессе это отменяется: в меню /rewind есть запись предыдущей сессии, она выглядит как /resume <id> (previous session).

Стоит помнить и про цену: /clear не стоит ничего, тогда как /compact — крупный запрос со всем контекстом. Если разговор больше не нужен, очистка дешевле сжатия на весь объём окна.

/clear                                       # новый разговор с чистым контекстом
/clear эксперимент с очередями, не взлетело  # то же, но прежний разговор подписан этой фразой

/resume [id или поисковая фраза]

Вернуться к прошлому разговору. Алиас: /continue. Нужна, когда работу прервали и продолжать хочется не с нуля, а со всем накопленным контекстом — или когда надо поднять давнее обсуждение, чтобы вспомнить, на чём тогда остановились.

Список привязан к рабочей папке: разговор из другого проекта в нём не появится. А вот по идентификатору сессия открывается из любой папки на машине — до версии 2.1.223 искали только в текущем проекте и его рабочих копиях. Для скриптов это удобно: забрали session_id из вывода claude -p --output-format json и продолжили откуда угодно.

Транскрипты чистятся по cleanupPeriodDays, по умолчанию через тридцать дней. Если рассчитываете возвращаться к старым разговорам, поднимите значение заранее — восстанавливать удалённое неоткуда.

Терминальные формы: claude -c продолжает последний разговор папки без выбора (фоновые сессии пропускает), claude -r открывает тот же выбор до старта сессии, claude -r <id> --fork-session продолжает старый разговор с новым идентификатором, оставляя исходный нетронутым.

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

/resume                    # выбор из последних разговоров этой папки
/resume 8f3c1d2e-4b5a-...  # открыть сразу по идентификатору, без выбора
/resume дедлок в пуле      # поиск по содержимому; выбор из совпавших разговоров

/branch [имя]

Ответвить разговор от текущей точки; оригинал сохраняется целиком.

Это «сохранись перед боссом». Вы в точке, где непонятно, какой из двух подходов лучше; ответвляетесь, пробуете первый, и если не вышло — возвращаетесь в оригинал через /resume и пробуете второй, не таща за собой неудачную попытку в контексте. Имя необязательное, но с ним потом проще найти нужную ветку в списке.

После команды вы оказываетесь в ответвлении и пишете дальше уже в нём; исходный разговор остаётся целым и открывается через /resume.

/branch                            # ответвиться от текущей точки
/branch попробовать-через-очередь  # то же, ответвление подписано этим именем

/fork [задача]

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

Это «пусть кто-нибудь займётся этим, пока я делаю своё». Копия получает весь накопленный контекст; результат вы заберёте, подключившись к ней через claude attach или экран claude agents. Начиная с 2.1.221 копии заодно велено завести собственную рабочую копию git, прежде чем править код, — чтобы два агента не наступали друг другу на ноги в одном дереве.

Осторожно с чужими инструкциями. В версиях с 2.1.161 по 2.1.211 то, что сейчас называется /subtask, называлось /fork, и имена поменялись местами в 2.1.212. Статья или скрипт, написанные до этого, имеют в виду прямо противоположное. Плюс частный случай: если экран агентов выключен, /fork возвращается к старому поведению и работает как субагент.

Учтите и расход: копия — это полноценная вторая сессия со своим контекстом, и пока она работает, лимит тратится одновременно с вашим.

Копия заводится сразу и получает свой идентификатор — он и нужен, чтобы потом к ней подключиться. С заданием она принимается за работу немедленно, без задания просто ждёт указаний.

/fork собери релизные заметки по коммитам с прошлого тега  # копия работает параллельно вам
/fork                                                      # копия ждёт указаний

/subtask <задача>

Отправить субагента с вашим контекстом; результат вернётся в этот же разговор.

Это «сходи посмотри и вернись». Отличие от /fork принципиальное: шумная часть работы — чтение двадцати файлов, простыни вывода — остаётся в контексте субагента, а к вам приходит только вывод. Главный способ не забивать основной контекст разведкой.

Требует версии 2.1.212; до неё эта команда называлась /fork. При выключенном экране агентов недоступна.

Экономится при этом ваше контекстное окно, а не расход: субагент читает и думает за ваш же лимит, просто не оставляет мусора в разговоре.

Разговор не встаёт: пока субагент читает, вы продолжаете писать, а по завершении в переписке появляется одно его сообщение с результатом.

/subtask найди все вызовы этого метода                                    # разведка без мусора в контексте
/subtask прочитай миграции за месяц и скажи, что менялось в схеме заказов  # то же для долгого чтения

/background [промпт]

Увести текущую сессию в фон и освободить терминал. Алиас: /bg.

Ничего не копируется — в фон уезжает эта самая сессия, работа продолжается. С аргументом вы заодно даёте ей задание на дорогу. Вернуться потом — claude attach или экран claude agents; остановить — /stop или claude stop <id>. Тянутся за ней, когда задача долгая, а терминал нужен прямо сейчас.

Терминал освобождается сразу, а сессия остаётся жить в фоне под своим идентификатором — по нему к ней и возвращаются.

/background                        # уйти в фон и освободить терминал
/bg догони сборку и почини линтер  # то же, плюс задание на дорогу

/rename [имя]

Переименовать сессию. Алиас: /name [нет в документации]. Смысл чисто практический: когда открытых и фоновых разговоров становится много, различать их надо по подписи, а не по идентификатору.

Имя видно в строке ввода, в списке /resume и в заголовке вкладки терминала. Без аргумента оно генерируется по теме разговора.

С введённым именем происходит три вещи: управляющие и невидимые символы заменяются пробелами, длина обрезается до двухсот знаков, а если после очистки не осталось ничего, имя отклоняется как пустое. Если такое имя уже занято другой живой сессией на этой машине, применится его вариант — не ошибка, просто имя окажется слегка другим.

Заголовок терминала меняется, если включено terminalTitleFromRename (по умолчанию да); совсем запретить трогать заголовок можно переменной CLAUDE_CODE_DISABLE_TERMINAL_TITLE.

/rename                     # имя придумывается по теме разговора
/rename рефакторинг оплаты  # имя задано вручную

/cd <путь>

Перевести сессию в другую рабочую папку. Пригождается, когда работа переехала в соседний сервис или репозиторий, а разговор бросать не хочется.

Настройки, хуки, MCP-серверы, навыки и агенты новой папки начинают действовать сразу, а не после перезапуска, и блок env новой папки накладывается поверх старого. Этим /cd отличается от /add-dir, который даёт доступ к файлам, но не к конфигурации.

/cd ../backend  # переехать в соседний репозиторий вместе с его конфигурацией

/recap

Сжать всю сессию в одну строку-резюме — быстро вспомнить, о чём шла речь. Полезна после перерыва и в длинном разговоре, где начало уже уехало за экран. Контекст при этом не трогается: это просто короткая выжимка в ответ, а не сжатие разговора, которым занимается /compact.

/recap  # о чём этот разговор и к чему в нём пришли

/btw [вопрос]

Задать короткий сторонний вопрос, не засоряя основной контекст: ответ не подмешивается в дальнейшую работу. Это для «а как вообще называется вот это» посреди задачи — чтобы через десять сообщений модель не строила рассуждения вокруг случайно заданного вопроса.

Без вопроса открывает ваши прошлые сторонние вопросы, чтобы полистать ответы; до версии 2.1.212 вопрос был обязателен.

/btw чем grpc-web отличается от grpc  # ответ виден вам, но мимо дальнейшего контекста
/btw                                  # вернуться к прошлым сторонним вопросам

/export [файл]

Выгрузить разговор в файл или буфер обмена. Обычно нужно, чтобы приложить переписку к задаче, переслать коллеге или сохранить разбор, к которому вы ещё вернётесь.

Без аргумента весь разговор уходит в буфер, с аргументом пишется в файл; ~ раскрывается. Формат текстовый, с разметкой ролей: это транскрипт для человека или для передачи в другой инструмент, а не машинный формат для импорта обратно.

/export                    # весь разговор в буфер обмена
/export ~/logs/session.md  # то же, но в файл

/copy [N]

Скопировать в буфер один ответ: без аргумента последний, с числом — N-й с конца. Нужна, когда из большого ответа надо забрать кусок в редактор или в тикет и не хочется выделять мышью полэкрана.

Считаются ответы ассистента, а не строки на экране, поэтому /copy 2 — это «предпоследний ответ». Малоизвестное: если в ответе есть блоки кода, открывается выбор — можно взять отдельный блок, а не всё сообщение. И прямо там клавиша w пишет выбранное в файл вместо буфера обмена; по SSH, где буфер бесполезен, это единственный рабочий способ.

Выбор в этом списке — между сообщением целиком и любым отдельным блоком кода из него; выбранное сразу уходит в буфер, а по w — в файл.

/copy    # последний ответ в буфер обмена
/copy 2  # предпоследний; если в нём есть код, сначала предложат выбрать блок

/stop

Остановить текущую фоновую сессию. Транскрипт и рабочая копия сохраняются. Нужна, когда фоновая работа ушла не туда или уже не нужна: сессия действительно прекращает работать, а не просто отсоединяется, как при /exit. Снаружи то же самое делает claude stop <id>.

/stop  # остановить фоновую сессию, транскрипт и рабочая копия остаются

/exit

Выйти из CLI. Алиас: /quit. В фоновой сессии — отсоединиться, сама сессия продолжит работать.

/exit  # выйти из CLI; в фоновой сессии — только отсоединиться

Контекст и память

/context [all]

Показать цветной сеткой, чем заполнен контекст, плюс советы, что можно выгрузить. Аргумент all разворачивает подробности: какие именно файлы и сколько занимают. Тянуться за ней стоит, когда сессия ощутимо потяжелела или вот-вот уйдёт в автосжатие: команда показывает, кто именно занял окно, а от этого зависит, чем лечить. Не путайте с /usage: та про лимиты тарифа, эта — про окно текущей сессии.

Каждая клетка сетки — кусок контекстного окна, раскрашенный по источнику. Смысл не в красоте: источники ведут себя по-разному, и лечатся они разным.

Практическая ценность именно в all: почти всегда находится один-два файла или один разговорчивый MCP-сервер, съевшие больше, чем вся полезная работа.

Дальше развилка. Распухла история — /compact. Распухли прочитанные файлы — /clear и начать заново. Распухли описания инструментов и навыков — это лечится настройками, а не командами: в следующей сессии контекст будет ровно таким же раздутым.

/context                                # чем занят контекст прямо сейчас

Context Usage
Opus 5 (1M context)
claude-opus-5[1m]
138.8k/1m tokens (14%)

Estimated usage by category
  System prompt:    4.4k tokens  (0.4%)
  System tools:      21k tokens  (2.1%)
  MCP tools:         265 tokens  (0.0%)
  Memory files:     3.2k tokens  (0.3%)
  Skills:           6.2k tokens  (0.6%)
  Messages:       104.2k tokens (10.4%)
  Free space:      860.7k       (86.1%)

MCP tools · /mcp (loaded on-demand)
└ 126 tools · 265 tokens

Memory files · /memory
└ 1 file · 3.2k tokens

Skills · /skills
└ 48 skills · 6.2k tokens

/context all to expand

 Suggestions
 ℹ File reads using 76.1k tokens (8%) → save ~22.8k
   If you are re-reading files, consider referencing earlier reads.
   Use offset/limit for large files.

/context all                            # то же, с разбивкой по каждому файлу

Вывод выше — дословный снимок реальной сессии на Opus 5 с окном в миллион токенов.

/compact [инструкции]

Сжать историю разговора в резюме, освободив место. Аргумент — не флаг и не фильтр, а инструкция составителю резюме: чему уделить внимание, что нельзя потерять. Нужна, когда окно почти заполнено, а бросать разговор рано: работа продолжится с того же места, но опираться дальше будет на пересказ.

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

Ничего не спрашивая, команда сворачивает историю и отчитывается одной строкой; само резюме по умолчанию свёрнуто и разворачивается отдельным нажатием. С аргументом внешне ничего не меняется — разница только в том, что удержано внутри резюме.

Само по себе сжатие — дорогой запрос: в него уходит весь контекст целиком. /clear не стоит ничего. Если разговор вам больше не нужен, вторая команда дешевле первой на весь объём окна.

Порогом, при котором контекст ужимается сам, управляет /autocompact.

/compact                                # сжать историю как получится

⎿ Compacted (ctrl+o to see full summary)

/compact сохрани решения по схеме БД     # сжать, но не потерять эту линию

/compact оставь только то, что относится к модулю оплаты

Строка отчёта приведена дословно, снята на сборке 2.1.220.

/autocompact [auto|<токены>]

Настроить, при каком заполнении контекст начнёт ужиматься сам. Команда появилась в 2.1.221. Порог — это компромисс: чем он выше, тем дольше живёт полная история, но тем ближе вы к потолку окна; чем ниже, тем чаще разговор превращается в пересказ. За командой тянутся, когда сжатие срабатывает не вовремя — слишком рано и уносит нужное или слишком поздно и упирается в потолок.

Значения вне диапазона не принимаются. Постоянный эквивалент — ключ autoCompactWindow, выключается автосжатие целиком через autoCompactEnabled: false, есть и флаг запуска --autocompact с теми же значениями. Отдельная настройка precomputeCompactionEnabled готовит сжатие заранее, пока идёт обычная работа, — когда порог будет достигнут, пауза окажется короче; работает только при включённом автосжатии.

Диалога команда не открывает: без аргумента она просто показывает действующий порог, с аргументом — принимает новый либо отказывается, если число вне допустимого диапазона.

/autocompact                            # посмотреть текущий порог

/autocompact auto                       # пусть подбирается сам

/autocompact 400000                     # сжимать, дойдя до 400k токенов

/memory

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

Что именно из них загружается, показывает /context, а привести их в порядок умеет /doctor: он вычищает дубли, переносит редко нужное в отдельные файлы, подгружаемые по требованию, и вырезает то, что агент и так выведет из кода.

/memory                                 # открыть файлы памяти на правку

/init

Создать CLAUDE.md: агент осмотрит репозиторий и опишет его структуру и команды. [Навык] Тянуться за ней стоит на репозитории, с которым агент ещё не работал; уже существующий файл обычно быстрее поправить руками через /memory, чем генерировать заново.

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

Успешно отработав, команда не печатает ничего. Проверять результат документация советует в следующей сессии: вызвать /context и убедиться, что CLAUDE.md появился в разделе Memory files.

Малоизвестная переменная: CLAUDE_CODE_NEW_INIT=1 включает интерактивный вариант, который проводит не только по инструкциям проекта, но и по навыкам, хукам и личным файлам памяти. И если в папке найдётся конфигурация другого кодинг-агента, которую умеет переносить /import, вам предложат её забрать.

/init                                   # сгенерировать CLAUDE.md по репозиторию

CLAUDE_CODE_NEW_INIT=1 claude    # интерактивный /init со скилами и хуками

/add-dir <путь>

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

Важная тонкость: он даёт доступ к файлам, а не к конфигурации — хуки и настройки той папки не подхватываются. Единственное исключение — навыки и команды: их из добавленной папки берут. Перевести сессию в другую папку целиком, вместе с её настройками и хуками, — это /cd, а не /add-dir.

/add-dir ../shared-protocol             # пустить агента в соседний репозиторий

/rewind

Откатить код и/или разговор к контрольной точке, либо сжать кусок разговора. Алиасы: /checkpoint, /undo. Нужна, когда серия правок увела не туда и разбираться, что именно агент наменял, дольше, чем вернуться на шаг назад.

Первое, что надо знать: команда работает не всегда. Копии файлов снимаются перед правкой, только если включено fileCheckpointingEnabled. Выключено — восстанавливать нечего.

Второе: меню открывается не только командой. Двойной Esc на пустой строке ввода делает то же самое. Если в строке есть текст, двойной Esc его очищает — поэтому сначала очистите строку.

В меню шесть пунктов, и половина из них не про откат:

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

Выбор здесь двухступенчатый: сначала точка, к которой возвращаетесь, потом одно из шести действий над ней. Из откатов чаще всего нужен «восстановить код»: правки пошли не туда, но обсуждение, из которого они выросли, ценно и терять его глупо.

Границы, которые стоит знать до того, как они понадобятся. Хранится сто последних контрольных точек, а вместе с сессией они удаляются через тридцать дней — тот же cleanupPeriodDays. Не восстанавливается: то, что сделали запущенные команды оболочки, большинство правок субагентов, изменения, внесённые снаружи, и всё, что лежит по символическим и жёстким ссылкам. То есть снесённая миграцией база не вернётся, git reset не отменится, установленные пакеты останутся. Это отмена последних правок, а не система контроля версий и не замена коммитам.

Восстановление кода не всегда полное: если у файла с момента точки поменялся тип или каталог, он будет пропущен, а сессия отдельно сообщит, сколько файлов не тронула.

/rewind                                 # меню отката и сжатия

Модель и производительность

/model [модель]

Сменить модель и запомнить выбор. [сверх тарифа] платит не сама команда, а часть того, что ей можно выбрать: Fable 5 и варианты с миллионным контекстным окном на ряде тарифов списываются из кредитов сверх подписки, и без включённых кредитов такие строки в списке не работают. Без аргумента открывается список доступного. Тянутся к команде, когда сменился характер работы: тяжёлый разбор имеет смысл вести на самой сильной модели, а поток мелких правок — на быстрой и дешёвой.

Выбор запоминается и переживает перезапуск — этим /model отличается от переменной ANTHROPIC_DEFAULT_MODEL, которую он перекрывает.

Расклад на август 2026. Актуальные модели — Opus 5, Sonnet 5, Fable 5 и Haiku 4.5. Пятого Haiku не существует: алиас haiku по-прежнему ведёт на 4.5, и это регулярно вводит людей в заблуждение при чтении примеров с fallbackModel.

Что стоит за алиасом, зависит от провайдера, и это неочевидная деталь для тех, кто работает через облако. На собственном API sonnet — это Sonnet 5, на Amazon Bedrock и Google Cloud — Sonnet 4.5, на Microsoft Foundry opus — вообще Opus 4.6. Один и тот же конфиг на двух провайдерах даёт разные модели.

Настраивается всё это тремя способами. Что стоит за алиасами — переменными ANTHROPIC_DEFAULT_OPUS_MODEL и родственными (для best такой переменной нет). Сам список выбора — ключом modelPicker: туда дописываются свои строки с подписями, в том числе идентификаторы Bedrock и Vertex, а replaceBuiltInOptions заменяет встроенный список целиком. Сверху всё ограничивается корпоративным availableModels; с версии 2.1.205 алиас семейства при этом не отвергается, а разрешается в новейшую разрешённую модель.

Отдельно живёт fallbackModel — список моделей, на которые Claude Code переключится сам, если основная перегружена. Это не смена вашего выбора, а страховка на время недоступности.

Что именно тарифицируется отдельно. У Fable 5 расчёт кредитами зависит от тарифа и типа места в организации; там, где он действует, в списке у этой строки стоит пометка о необходимости кредитов, а перед первым таким запросом Claude Code один раз спросит подтверждение. В неинтерактивном режиме (-p) и через Agent SDK этого вопроса нет — списание произойдёт молча. С миллионным окном картина другая: у Sonnet 4.6 оно требует кредитов на любом подписочном тарифе, включая Max; у Opus — только на Pro, а на Max, Team и Enterprise входит в тариф без всякой настройки. У Sonnet 5 на собственном API миллионное окно включено всегда и кредитов не требует.

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

/model                # выбрать из доступного списка
/model opus           # по алиасу
/model opusplan       # планировать на Opus, выполнять на Sonnet

/effort [уровень|auto|status]

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

Четыре неочевидности.

max нельзя сохранить в настройках. Ключ effortLevel принимает только значения до xhigh. Максимум задаётся на сессию — командой или флагом --effort max — и намеренно не остаётся включённым навсегда. Так же устроен ultracode: команда и флаг работают, а из перечисленных в схеме значений его нет; постоянно он включается отдельным булевым ключом ultracode.

Уровень запоминается по модели. С версии 2.1.248 у каждой модели свой сохранённый уровень: переключились на другую — получите её настройку, а не вашу последнюю.

Другие команды его перебивают. /code-review high поднимает усилия на ход, /code-review low понижает, даже если сессия шла на xhigh.

Слово ultracode работает прямо в тексте промпта — по умолчанию его достаточно, чтобы включить оркестровку на один ход; отвечает за это workflowKeywordTriggerEnabled. Если сработало случайно, отменяется на месте сочетанием Alt+W (на macOS Option+W). Чтобы стартовать сразу с ним: claude --effort ultracode.

Отдельно про расход на ultracode. Сверх тарифа он не тарифицируется, но один ваш запрос разворачивается в несколько воркфлоу подряд, а каждый воркфлоу плодит агентов — лимит тарифа при этом тает заметно быстрее обычной сессии. Предупреждение о крупном прогоне, которое Claude Code показывает, когда планируется больше 25 агентов или прогноз переваливает за полтора миллиона токенов, в режиме ultracode не выводится: включив его, вы уже согласились на большие прогоны. На тарифе Pro оркестровку воркфлоу сначала надо включить в /config.

Ещё в 2.1.251 починили частный случай, на который легко наткнуться: Opus 5 отказывался работать с xhigh и max, если размышления выключены. Теперь в такой комбинации усилия просто отправляются как high.

С аргументом уровень переключается на месте, к текущей сессии; status ничего не меняет и только показывает действующий уровень.

/effort status     # какой уровень сейчас
/effort low        # дёшево и быстро
/effort ultracode  # xhigh плюс постоянная оркестровка воркфлоу

/fast [on|off]

Fast-режим: та же модель, но с ускоренным выводом. [сверх тарифа] бесплатной нормы у него нет — режим всегда оплачивается кредитами сверх подписки, даже если лимит тарифа ещё не выбран, а пока кредиты не включены, команда сообщит, что они нужны, и ничего не переключит. Тянутся к нему там, где ждать дороже, чем платить: диалоговая отладка, длинная серия мелких правок, демонстрация вживую. Это не другая модель и не другой уровень усилий — это режим выдачи.

Цена ускорения на Opus 5 и Opus 4.8 — 10 долларов за миллион входных токенов и 50 за миллион выходных, одинаково на всём миллионном окне; это дороже обычных ставок Opus. Есть неприятная тонкость с первым включением внутри диалога: весь уже накопленный контекст пересчитывается по полной цене входа fast-режима, поэтому включать его дешевле в начале сессии, а не на сотом ходу. Если кредиты кончатся посреди работы, ничего не сломается — Claude Code повторит отклонённые запросы на обычной скорости и по обычной цене. В Claude Console кредитов нет вовсе: организация платит за токены вместе с остальным API-расходом. На Amazon Bedrock, Claude Platform на AWS, Google Cloud Agent Platform и Microsoft Foundry режима нет.

Ключи настроек рядом: fastMode включает его постоянно, а fastModePerSessionOptIn заставляет каждую сессию стартовать без него, даже если вы включали его в прошлый раз.

/fast on   # ускоренный вывод
/fast off  # обратно

/brief

Режим «только кратко»: максимально сжатые ответы без развёрнутых пояснений. Аргументов у команды нет. Полезно, когда вы ведёте работу сами и от агента нужен результат или короткий факт, а не разбор с примерами. На объём самой работы и на глубину рассуждений это не влияет — сокращается только то, что печатается вам; за глубину отвечает /effort.

/brief  # отвечать максимально коротко

/advisor [модель|off]

Советчик: более сильная модель подсказывает основному агенту в ключевые моменты. [не на всех тарифах] нужен доступ к собственному API Anthropic — по подписке или через Console; на Amazon Bedrock, Claude Platform на AWS, Google Cloud Agent Platform и Microsoft Foundry советчика нет, и ему требуется включённое получение флагов возможностей. Смысл в том, чтобы не платить за сильную модель на всей сессии, а звать её точечно. Возможность экспериментальная, и вести на ней рабочий процесс пока рано.

Вторая модель вмешивается не постоянно, а в ключевых точках — когда основной агент принимает решение, где ошибка дорого стоит. Аргумент — алиас или полный идентификатор модели; off выключает. Без аргумента открывается выбор. Есть и флаг запуска --advisor <модель>, которого, кстати, нет в выводе claude --help.

Расход советчика идёт с обычного лимита тарифа — с одним исключением: если советчиком назначен Fable 5, его работа оплачивается кредитами там же, где кредитами оплачивается обычное использование Fable 5. Пока согласие на такое списание не дано через /model fable, Claude Code просто не назначит Fable советчиком.

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

/advisor       # выбрать советчика из списка
/advisor opus  # подсказки от Opus
/advisor off   # выключить советчика

/plan [open|share|описание]

Режим планирования: агент читает, анализирует и предлагает план, но ничего не меняет — правки файлов и опасные команды недоступны. Выход — принятие плана; после него сессия возвращается в обычный режим и начинает его выполнять. Нужен он там, где цена неверно понятой задачи выше, чем время на согласование: перед крупной переделкой, в незнакомом коде, когда правка расходится по десятку файлов.

Файлы планов лежат в ~/.claude/plans/, если не задан plansDirectory — им их переводят в репозиторий проекта, чтобы план обсуждался и версионировался вместе с кодом.

В диалоге принятия плана есть опция «очистить контекст»: план остаётся, а вся разведка, на которой он построен, выбрасывается. Показывается она только при showClearContextOnPlanAccept, по умолчанию выключена, и на длинных задачах это одна из самых полезных настроек — исполнение начинается с чистым окном.

Режим доступен и с самого старта: claude --permission-mode plan. И отдельно стоит знать, что авто-режим по умолчанию действует и внутри планирования; отключается это ключом useAutoModeDuringPlan.

Готовый план показывается вместе с диалогом принятия, и выбирать в нём приходится из трёх вариантов. «Yes, and use auto mode» — принять и продолжить в авто-режиме; там, где авто-режим недоступен, та же строка называется «Yes, auto-accept edits», а в сессии, запущенной с обходом разрешений, — «Yes, and switch to BYPASS PERMISSIONS (no further prompts) for this session». «Yes, manually approve edits» — принять, но подтверждать каждую правку вручную. «No, keep planning» — остаться в планировании и сказать, что поправить. Так это описано в документации.

/plan                                    # войти в режим планирования
/plan вынести оплату в отдельный сервис  # войти сразу с задачей
/plan share                              # поделиться планом

/goal [условие|clear]

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

Условие должно быть проверяемым — команда, состояние файла, признак в выводе. Расплывчатое «пока не станет хорошо» превращается в бесконечную работу, потому что проверить его нечем.

Отдельная статья расходов, о которой мало кто думает: пока цель активна, агент периодически просыпается и проверяет застрявшую фоновую работу, и каждая такая проверка — полноценный ход с полным контекстом. Частоту задаёт CLAUDE_CODE_GOAL_CHECKIN_MINUTES, ноль отключает проверки совсем; с версии 2.1.246 их не больше трёх на цель.

/goal пока все тесты не станут зелёными    # работать до выполнения условия
/goal                                      # показать текущую цель
/goal clear                                # снять цель

Код-ревью и качество

Первые три команды смотрят на один и тот же дифф и потому легко путаются, четвёртая вообще ничего не анализирует:

/code-review [уровень|ultra] [--fix] [--comment] [--post|--no-post] [цель]

Ревью диффа на ошибки и упрощения [Навык]. Алиас: /review. Обычное локальное ревью идёт в счёт лимитов вашего тарифа, а вот облачный режим ultra — [сверх тарифа]: на Pro и Max по три бесплатных запуска, дальше списание из кредитов, обычно от пяти до двадцати пяти долларов за ревью, а если кредиты не подключены, платный запуск просто блокируется. Тот же ultra — ещё и [не на всех тарифах]: нужен вход в claude.ai, на сторонних провайдерах и в организациях с нулевым хранением данных его нет.

Самая настраиваемая из встроенных команд: уровень усилий, четыре флага, цель ревью и отдельный облачный режим — и каждое разбирается по своим правилам. Полная форма — /code-review [low|medium|high|xhigh|max|ultra] [--fix] [--comment] [--post|--no-post] [<PR#>|<ветка>|<путь>|<заметка>], и всё в ней необязательно: голое /code-review — валидный вызов.

Что она ищет. Две разные вещи. Ошибки корректности: перевёрнутое условие, off-by-one, разыменование null, забытый await, снятая проверка, проглоченная в catch ошибка, сломанные вызывающие изменённой функции, классические грабли конкретного языка. И чистоту: новый код, повторяющий уже существующее в репозитории; лишнюю сложность и мёртвый код; лишнюю работу вроде повторных вычислений или последовательно выполненных независимых операций; «не тот уровень решения», когда заплатка ставится там, где надо было чинить общий механизм; прямые нарушения правил из вашего CLAUDE.md.

Ошибки корректности всегда важнее находок про чистоту: если находок больше лимита уровня, режут сначала вторые. Само ревью ничего не правит, пока не передан --fix.

Где оно выполняется. Обычно фоновым агентом: сессия не блокируется, находки приходят отдельным сообщением. В трёх случаях ревью занимает сессию целиком: если вы запустили его повторно, пока предыдущее ещё идёт; если вы в неинтерактивном режиме -p или в SDK; и если выставлена переменная CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1, которая вообще отключает фоновые задачи.

Кто может его запустить. Не только вы. На просьбу «посмотри мои изменения» обычным текстом агент запустит ревью сам, и запланированная задача с /code-review в промпте тоже сработает. Если это мешает — оставить команду набираемой, но запретить агенту и расписанию её запускать:

{
  "skillOverrides": { "code-review": "user-invocable-only" }
}

Облачный режим — исключение: ultra агент не запускает никогда, ни сам, ни по расписанию.

Порядок аргументов. Три правила, из-за которых вызов срабатывает не так, как ожидалось:

1. ultra понимается только первым словом. /code-review ultra --fix — облачное ревью, а /code-review --fix ultra — обычное локальное, в котором слово ultra понято как цель.
2. Уровень — первое слово после того, как из строки убраны флаги. Поэтому /code-review --fix high работает, и уровень будет high.
3. Флаги можно ставить где угодно: в начале, в конце, между уровнем и целью. Единственное исключение — правило 1.

И четвёртое, отдельное: эта команда «съедает» команду, набранную следом. Обычно несколько навыков стыкуются в одном сообщении, и /write-tests /fix-issue 123 загрузит оба. Но /code-review /fix-issue 123 с версии 2.1.218 понимает /fix-issue 123 как текст цели, а не как вторую команду. До 2.1.218 было наоборот.

Уровни усилий.

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

Точный конвейер зависит от модели сессии, поэтому таблица про смысл уровней, а не про гарантированное число агентов. На Opus 5 medium и high сейчас сводятся к одному внимательному проходу с лимитом в пятнадцать находок, а различия начинаются с xhigh; на Sonnet 5 на уровнях high, xhigh и max число поисковых агентов подбирается по размеру диффа — от двух до восьми.

Отдельной платы за верхние уровни нет, но каждый поисковый агент ведёт свой контекст, поэтому xhigh и max расходуют лимит тарифа заметно быстрее, чем low. Гонять max на каждую мелкую правку — самый простой способ остаться без недельного лимита к среде.

Запоминание уровня. Если уровень не указан, берётся тот, который вы набрали в прошлый раз: он живёт между сессиями, и в начале отчёта об этом скажут строкой вида «использую high, уровень с прошлого раза». Два исключения: уровень, переданный в неинтерактивном запуске -p, ничего не запоминает, а ultra запомненный уровень и не читает, и не меняет. Если вы не набирали ни разу, берётся уровень усилий текущей сессии. Набранный уровень заодно задаёт усилия модели на ход, в том числе вниз: /code-review low в сессии на xhigh их понизит.

Опечатка вызов не ломает: на /code-review higher вы получите предупреждение, что значение не распознано, и прошлый или дефолтный уровень. Сокращение med принимается как medium.

Флаги.

--fix правит найденное прямо в рабочем дереве, и ошибки, и чистоту. Находка пропускается, если правка меняет задуманное поведение, требует изменений далеко за пределами просмотренного диффа или выглядит ложным срабатыванием; в конце вам скажут, что пропустили и почему. С ultra правки применяются локально в тот момент, когда облако вернёт результат.

--comment требует, чтобы целью был pull request. Если цель не он, флаг игнорируется, находки просто печатаются, и агент об этом скажет. Комментарии уходят через GitHub-интеграцию, а если её в сессии нет — через gh api.

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

--no-post нужен, чтобы вообще не видеть предложения постить. Передавать оба сразу бессмысленно: команда читает только --post, так что --post --no-post всё равно предложит запостить.

Цель ревью. Без цели ревьюится текущая работа: коммиты ветки над её upstream плюс незакоммиченные изменения. Поэтому команда осмысленна и до коммита.

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

Ревью в облаке: что нужно, сколько стоит и где потолок. ultra запускает фоновый агент в Claude Code в вебе: он клонирует репозиторий в облачную песочницу, гоняет по диффу мульти-агентный поиск и присылает находки уведомлением в вашу сессию. Занимает минуты, всё это время можно работать дальше.

Требуются git-репозиторий и GitHub-remote, аккаунт claude.ai с подключённым GitHub, а для приватного репозитория — установленное на владельца приложение Claude. Недоступно на сторонних провайдерах, при отключённых необязательных запросах, в организациях с нулевым хранением данных и при запрете со стороны организации. Важная деталь: когда режим недоступен, /code-review ultra не падает, а тихо выполняет обычное локальное ревью — если вы ждали облачного, стоит убедиться, что оно действительно запустилось.

Потолок диффа — до пятисот изменённых файлов и восьми тысяч изменённых строк. Слишком большой pull request отклоняется, и в отказе называются действующие лимиты, размер вашего диффа и самые крупные файлы; пустой дифф тоже отклоняется.

Цена: на Pro и Max по три бесплатных запуска — они даются аккаунту разово и не обновляются, — а на Team и Enterprise бесплатных нет вовсе. Дальше — из кредитов, обычно от пяти до двадцати пяти долларов за ревью в зависимости от размера изменений. Запуск считается с момента старта облачной сессии: остановленное или упавшее ревью бесплатный запуск всё равно потратит, а платное списывается только за отработанную часть. Если кредиты не подключены, платный запуск просто блокируется.

Что вы подтверждаете перед стартом. Платный облачный запуск не уходит молча: сначала показывают окно с оценкой стоимости и просят согласиться на списание кредитов — один раз за разговор. Там же, если передан --post, вы решаете, постить ли итог комментарием в pull request или оставить находки только у себя. Пока вы не подтвердили, облачная сессия не стартует.

Из CI. С версии 2.1.218 облачное ревью запускается неинтерактивно:

claude -p '/code-review ultra'

Команда стартует ревью, печатает ссылку для отслеживания и не ждёт результата. Но если ревью должно списать кредиты, запуск остановится: подтверждение оплаты требует интерактивной сессии. Для такого случая есть отдельная подкоманда, сам факт запуска которой считается вашим согласием на списание:

claude ultrareview                       # облачное ревью текущей ветки
claude ultrareview 1234 --post           # ревью PR, итог комментарием в него
claude ultrareview --json                # сырые находки вместо отчёта
claude ultrareview dev --timeout 60      # против ветки dev, ждать до часа

Код выхода — 0, если ревью завершилось (с находками или без), и 1, если запустить его не удалось. --timeout по умолчанию тридцать минут.

Канонической формой считается /code-review ultra; /ultrareview — её алиас, доступный не всем аккаунтам, и вся возможность помечена как исследовательская. В статьях часто пишут наоборот, будто основная команда — /ultrareview.

В GitHub Actions. У ревью есть отдельная жизнь в CI, и там оно настраивается не флагами, а файлом. В корне репозитория кладётся REVIEW.md, который задаёт правила: какие пути и ветки пропускать, какие категории находок не показывать, что считать важным, как вести себя при повторном ревью одного и того же pull request.

Находки делятся на три уровня: важные, придирки и уже существовавшие в коде до этих изменений. Нарушения ваших правил из CLAUDE.md попадают в придирки. Проверка всегда завершается нейтральным статусом и поэтому никогда не блокирует слияние сама — но последней строкой печатает счётчик находок в JSON вида {"normal": 2, "nit": 1, "pre_existing": 0}, по которому вы можете поставить собственный барьер в своём же пайплайне.

Что придёт в ответ, зависит от режима: обычное ревью присылает отчёт отдельным сообщением, --fix добавляет к нему правки в рабочем дереве, --comment уводит находки комментариями в pull request, а ultra сначала спросит подтверждение в окне запуска и только потом даст ссылку на облачную сессию.

/code-review                                   # текущие изменения, уровень как в прошлый раз
/code-review high --fix                        # глубже и сразу починить найденное
/code-review medium --comment 1234             # ревью PR 1234 с комментариями прямо в нём
/code-review ultra 1234 --post                 # облачное ревью PR, итог комментарием

/simplify [цель]

Найти в изменённом коде упрощения и сразу их применить [Навык]. Это уборка за собой, когда код уже работает: ошибок команда не ищет вовсе, поэтому проходит быстрее ревью — но и заменить его не может. Тянуться за ней стоит, когда правка успела разрастись: появились почти одинаковые куски, свои помощники поверх уже существующих, лишние промежуточные слои.

Смотрит на тот же дифф, что и /code-review, но ищет только чистоту, и делает это четырьмя параллельными агентами: переиспользование уже написанных помощников, упрощения, эффективность и тот ли это уровень абстракции. Ошибок он не ищет принципиально — это разделение труда, а не недоработка. И, в отличие от ревью, сразу применяет найденное. Аргумент — необязательная цель: путь, папка или номер pull request.

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

Историческая ловушка: до версии 2.1.147 /simplify называлась нынешняя /code-review и правки применяла по умолчанию. Старый скрипт, который звал /simplify ради поиска ошибок, сегодня делает совсем другое.

Выбирать по ходу не придётся: команда ничего не спрашивает, а в ответ приходит перечень применённых упрощений — правки к этому моменту уже в рабочем дереве.

/simplify                                # весь изменённый код
/simplify src/payments                   # только эта папка

/security-review

Проверить изменения ветки на уязвимости. Аргументов нет. Это третий взгляд на тот же дифф, но с другой оптикой: не «работает ли» и не «аккуратно ли написано», а что отсюда можно вытащить или сломать снаружи. Звать её осмысленно перед тем, как ветка уедет в общий репозиторий, — особенно если правка трогала аутентификацию, разбор пользовательского ввода или секреты.

Ищет инъекции, проблемы авторизации и аутентификации, утечки данных, небезопасную работу с секретами и вводом.

Единственное требование, о которое спотыкаются: нужен remote с именем origin — дифф считается против его основной ветки. Без него команда падает с ошибкой git про неоднозначный аргумент, и выглядит это загадочно.

В ответ приходит перечень найденного: место в коде, характер проблемы и чем она опасна.

/security-review                         # уязвимости в изменениях ветки

/diff

Интерактивно посмотреть незакоммиченные изменения. Аргументов нет. Ничего не анализирует, это просмотрщик: незакоммиченные изменения и, что полезнее, дифф по каждому ходу агента отдельно. Пригождается, когда агент наработал за несколько ходов и надо понять, на каком именно шаге он свернул не туда, — то есть штука, которой стоит пользоваться до /rewind, а не после.

Внутри вы выбираете, что смотреть: всю незакоммиченную работу целиком или один конкретный ход агента. Выход из просмотрщика возвращает вас в ту же сессию и ничего в коде не меняет — откат живёт в /rewind, здесь его нет.

/diff                                    # посмотреть незакоммиченное

Разработка и рабочие процессы

/run и /verify постоянно путают: обе про «проверить вживую», но отвечают на разные вопросы.

/run

Запустить приложение проекта и проверить изменение вживую, а не только тестами. [Навык] Берут её, когда по диффу ничего не понятно: поменялся экран, поведение формы, вывод команды — надо просто увидеть работающее приложение. С /verify не путать: та отвечает за одну конкретную правку, а /run поднимает всё как есть.

Речь про приложение целиком: поднять его так, как оно поднимается в этом проекте, и дать посмотреть. Чтобы он знал, как именно, нужен навык запуска — его создаёт /run-skill-generator, один раз на проект. Без него /run попытается угадать по типу проекта и на нестандартной сборке угадает плохо.

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

/run  # запустить приложение и посмотреть глазами

/verify

Подтвердить, что изменение работает: собрать, запустить, понаблюдать поведение. [Навык] Берут её сразу после правки, когда важно не поверить диффу, а увидеть результат. Проверяется именно изменение, а не приложение целиком — для второго есть /run.

Логика простая: ревью проверяет, что дифф правильно читается, /verify — что он правильно работает.

С версии 2.1.200 команда умеет записать найденный рецепт проверки в собственный навык .claude/skills/verify/SKILL.md, и тогда в корне репозитория он заменяет встроенный — то есть один раз разобрались, как проверять этот проект, и дальше это работает у всех.

Важное изменение: с версии 2.1.215 /verify запускается только вами. Раньше агент мог позвать его сам. То же случилось с /deep-research в 2.1.218. Если вы читали статью, где написано, что агент проверит себя сам, — она устарела.

Проверка идёт до конца сама: сборка, запуск, наблюдение за поведением, — а в конце вы получаете вывод о том, сошлось или нет и что именно смотрели. Если рецепта проверки в репозитории ещё не было, попутно предложат его записать.

/verify  # собрать, запустить, убедиться что работает

/run-skill-generator

Создать навык, умеющий запускать приложение этого проекта, — на нём потом работает /run. [Навык] Команда разбирается, как здесь всё собирается и стартует, и записывает найденный рецепт в навык, который лежит в репозитории и работает у всех.

Делается один раз на проект.

Работа тут не мгновенная: приложение действительно поднимают с нуля, запоминая, какие команды установки, переменные окружения и скрипт запуска сработали. Результат — файл навыка в репозитории, а не текст в терминале.

/run-skill-generator  # научить проект команде /run

/batch <инструкция>

Спланировать масштабную правку и выполнить её параллельно в 5–30 изолированных рабочих копиях, каждая открывает свой pull request. [Навык] Нужна там, где одинаковую правку надо внести в десятки мест и каждое место — самостоятельный кусок работы. Для одной правки в паре файлов она избыточна: накладные расходы на веер съедят весь выигрыш.

Самая тяжёлая из встроенных команд и единственная, которая по умолчанию порождает десятки агентов. Инструкция сначала превращается в план — список конкретных мест, которые надо править, — а потом под каждое место запускается свой агент в своей изолированной рабочей копии git, и каждый открывает отдельный pull request.

Ключевое здесь — изоляция. Агенты правят файлы параллельно, и без отдельных рабочих копий они бы наступали друг другу на ноги. Отсюда требования: git-репозиторий, чистое дерево и настроенный gh, иначе pull request открывать нечем.

Число агентов — от пяти до тридцати, и оно выводится из плана, а не задаётся вами: сколько нашлось мест, столько и агентов, в пределах потолка. Если план получается на два места, веер не нужен, и команда об этом скажет.

Отдельной платы за неё нет, но лимит тарифа она ест кратно: двадцать агентов — это двадцать сессий, каждая со своим контекстом.

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

На поведение веера влияют настройки worktree: symlinkDirectories спасает диск, если в проекте тяжёлые зависимости, sparsePaths ускоряет выгрузку в больших монорепозиториях, baseRef определяет, ветвиться от удалённой основной ветки или от текущего локального состояния.

Порядок такой: сначала вам показывают план и ждут согласия — это момент, когда решается, столько ли мест нашлось, сколько вы ожидали. После одобрения агенты уходят работать в фон, и ссылки на открытые pull request'ы появляются по мере готовности.

/batch переведи все контроллеры на новый клиент  # веер изолированных агентов, каждый со своим PR

/batch разнеси общие DTO по модулям, которые их используют  # если мест мало, веер не нужен — команда это скажет

/debug [описание]

Включить отладочные логи на сессию и помочь разобраться с проблемой. [Навык] Пригождается, когда непонятно, чья это беда — ваша или самого агента: в подробных логах видно, какие инструменты вызывались и чем ответили. Логи включаются до конца сессии, на следующую не переносятся.

Описание необязательное — с ним вы сразу говорите, что именно ловите.

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

/debug                                       # включить отладочные логи

/debug падает только на CI, локально зелено  # то же плюс описание проблемы

/fewer-permission-prompts

Просмотреть транскрипты, найти частые безопасные вызовы и собрать из них список разрешений. [Навык] Смысл — перестать подтверждать по десять раз на дню одно и то же безобидное чтение. Команда смотрит вашу же историю, а не общий список, поэтому разрешения получаются под конкретный проект.

Правка ложится в настройки проекта, то есть подействует у всех, кто с этим репозиторием работает.

На выходе — предложенный список разрешений, отсортированный по тому, что подтверждалось чаще всего; выбирать вам, целиком его принять или вычеркнуть лишнее перед тем, как он ляжет в настройки проекта.

/fewer-permission-prompts  # собрать список разрешений из истории

/commit [пожелания]

Собрать коммит: посмотреть статус и дифф, написать сообщение по принятому формату. [Навык] Формат сообщения выводится из истории коммитов этого репозитория, а не из общих правил, — в чужом проекте коммит будет выглядеть как соседние. Полезна ровно тем, что снимает два скучных шага: решить, что войдёт в коммит, и сформулировать, что вы, собственно, сделали.

Аргумент — не флаги, а пожелания обычным текстом; это верно и для /pr. Пожелания влияют на то, что попадёт в коммит и как будет написано сообщение.

Что попадёт в сообщение коммита в качестве атрибуции, задаётся объектом attribution с полями commit и pr, где пустая строка убирает её совсем. Выключить встроенные инструкции про коммиты целиком можно через includeGitInstructions: false — тогда агент будет пользоваться только вашими правилами.

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

/commit  # коммит с сообщением по формату проекта

/commit только изменения в схеме, остальное не трогай  # в коммит войдут только файлы схемы

/pr [пожелания]

Открыть pull request: завести ветку, запушить, создать описание через gh. [Навык] Описание собирается по тому, что реально в диффе, — не по вашему пересказу. Три шага вручную занимают пару минут, и обычно на описании как раз экономят; здесь оно пишется само.

Ветка заводится, если вы ещё на основной. Пожеланиями задаются черновик, ревьюеры, форма описания.

Шаги идут подряд — ветка, push, создание запроса через gh, — и в конце у вас на руках ссылка на открытый pull request. Пожелания вроде «черновиком» меняют то, каким запрос откроется, но не порядок шагов.

/pr  # ветка, пуш, pull request с описанием

/pr черновиком, ревьюеров не назначай  # то же, но запрос откроется черновиком

/commit-push-pr

Все три шага одним заходом: коммит, пуш, pull request. [Навык] То же, что /commit и /pr подряд, но без пауз между ними — для случая, когда работа явно закончена и обсуждать нечего. Если хочется посмотреть на коммит до того, как он уедет, лучше идти двумя командами.

У него есть особенность: опасные флаги git и gh не одобряются автоматически. --force, --amend, --no-verify всё равно спросят подтверждение, даже если у вас щедрые права. Сделано намеренно: цепочка из трёх шагов выполняется быстро, и человек не успевает заметить, что где-то в середине переписывается история.

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

/commit-push-pr  # все три шага сразу

/update-config

Поменять настройки: хуки, права, переменные окружения, — с правкой settings.json за вас. [Навык] Главный её случай — поведение вида «каждый раз, когда…»: такое умеет только хук, просьбами и памятью этого не добиться, потому что выполняет их не модель, а сама программа. Скажите словами, что должно происходить, — команда разберётся, в какой файл настроек это писать и в каком виде.

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

Прежде чем что-то менять, вам объяснят, какая настройка появится и в каком файле, — и если файл выбран не тот, это ровно тот момент, когда стоит вмешаться.

/update-config добавь хук на форматирование после правок

/claude-code-docs [вопрос]

Ответы про сам Claude Code: возможности, настройки, SDK, Claude API, Slack-приложение. [Навык] Отвечает по документации, а не по памяти модели, — а это разные вещи, потому что программа меняется от версии к версии быстрее, чем обновляются знания модели. Спрашивать лучше человеческой фразой, как спросили бы коллегу.

В ответ приходит разбор по документации со ссылками на её разделы — по ним же удобно проверить, что ответ не выдуман.

/claude-code-docs как ограничить агенту доступ к папке

/claude-in-chrome

Разрешить работу в вашем Chrome: кликать, заполнять формы, читать консоль. [Навык] [не на всех тарифах] — требуется вход в аккаунт claude.ai: с API-ключом и через Amazon Bedrock, Google Cloud и Microsoft Foundry расширение недоступно. Работа идёт в вашем настоящем браузере, с вашими вкладками и сессиями, — поэтому она годится там, где проверять надо не код, а живую страницу: воспроизвести баг в интерфейсе, пройти форму, посмотреть ошибки в консоли.

Доступ выдаётся по сайтам и настраивается в самом расширении: на страницу, которую вы не разрешили, агент не пойдёт.

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

/claude-in-chrome  # разрешить работу в браузере

/plugin-types [папка]

Сгенерировать типы входных данных подключённых MCP-инструментов. Команда читает описания инструментов и раскладывает их в типы, чтобы в коде плагина вызовы проверялись компилятором, а не угадывались по памяти. Аргумент — папка плагина, для которого генерировать. Нужна при разработке своего плагина; в обычной работе с проектом не пригодится.

Смотреть тут особо не на что: результат команды — файлы с типами внутри указанной папки плагина.

/plugin-types ./my-plugin  # типы MCP-инструментов для плагина

/workflow-authoring

Справочник по написанию скриптов для воркфлоу. [Навык] Рассказывает, из чего складывается скрипт, как устроено возобновление после сбоя и на чём обычно спотыкаются. Читают её перед тем, как писать свой воркфлоу, а не во время его выполнения.

Сам запуск воркфлоу не разрешает.

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

/workflow-authoring  # как писать скрипты воркфлоу

/claude-api [migrate|upgrade|prompt-audit|managed-agents-onboard|cost-optimize]

Помощь по Claude API и SDK. [Навык] Единственная в этой группе команда с фиксированным набором аргументов. Нужна, когда вы пишете код, который сам ходит в Claude: идентификаторы моделей, параметры, стриминг, вызов инструментов, кэширование — всё это сверяется с документацией, а не с памятью модели.

Аргумент выбирает сценарий: без него это общая справка, с ним — конкретная работа по вашему коду.

Навык включается и сам, без команды: если в коде проекта есть импорт официальной библиотеки Anthropic, он активируется при задачах, которые её касаются.

С аргументом команда сначала читает ваш код и возвращается со списком мест и предложенными правками — принимать их все или по одному, решаете вы.

/claude-api migrate       # миграция на новую модель

/claude-api prompt-audit  # найти в промптах инструкции под старые модели

/deep-research <вопрос>

Веер веб-поисков по множеству источников, проверка фактов и отчёт со ссылками. [Воркфлоу] Берут её, когда одного поиска мало: вопрос спорный, источники противоречат друг другу или нужен не первый попавшийся ответ, а сверенный. Поиск идёт несколькими независимыми линиями, найденное сопоставляется между собой, и в отчёте видно, на чём именно вывод держится.

С версии 2.1.218 запускается только вами — раньше агент мог позвать её сам.

Это динамический воркфлоу: агентов запускается много, и один запуск съедает лимит тарифа заметно быстрее обычной сессии. На тарифе Pro динамические воркфлоу сначала включают строкой Dynamic workflows в /config.

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

/deep-research чем отличаются подходы к идемпотентности в очередях

Субагенты, фоновые задачи, автоматизация

/list-agents

Показывает всех, кому можно написать прямо из сессии: субагентов, которых вы запустили, тиммейтов, другие сессии Claude Code на этой машине и облачные. Имя в списке — это адрес: скопировали его и отправляете сообщение именно этому агенту. За списком тянутся не ради любопытства, а когда надо понять, кто ещё жив и как к нему обратиться. Алиас: /peers.

Тиммейты (агент-команды) по умолчанию выключены везде и включаются переменной CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 — пока её нет, строк с ними в списке не будет. И стоит помнить цену: команда агентов расходует примерно всемеро больше токенов, чем обычная сессия, потому что у каждого тиммейта своё контекстное окно и он тратит, пока не завершится.

Команда только печатает перечень и ничего не предлагает выбрать: имя нужного агента вы берёте оттуда сами и дальше подставляете в сообщение.

/tasks

Показывает всё, что работает рядом с диалогом: фоновые задачи, запущенные процессы, их состояние и сколько уже крутятся. Отсюда же ими управляют — это единственное место, где видно сразу все запущенные сборки и прогоны тестов. Пригодится, когда их несколько и непонятно, кто из них ещё жив, а кто давно упал. Алиас: /bashes.

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

/daemon

Управляет фоновыми службами Claude Code — теми, что работают вне вашего диалога: ассистентами, запланированными задачами и удалённым управлением. Сюда идут, когда что-то из этого должно включиться, выключиться или перестать срабатывать. Обратите внимание: часть этих служб — запланированные задачи и удалённое управление — живёт только при входе в аккаунт claude.ai, и по ключу API их просто не будет.

Выбор здесь между службами, а не между задачами: вы находите нужную строку и переключаете её состояние, всё остальное происходит само.

/workflows

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

Один такой прогон съедает заметно больше токенов, чем та же работа в обычном диалоге, — агентов много, у каждого свой контекст. Тарифицируется это как обычный расход, отдельного счёта нет. Когда в прогоне больше 25 агентов или прогноз переваливает за 1,5 миллиона токенов, Claude Code предупреждает заранее; в режиме ultracode предупреждение не показывается — включив его, вы уже согласились на большие прогоны. На тарифе Pro сами воркфлоу сначала включают в /config.

/loop [интервал] [промпт]

Повторять промпт или команду по интервалу; без интервала темп выбирается сам. Алиас: /proactive. [Навык]

Команда принимает две вещи подряд: необязательный интервал и то, что повторять. Повторять можно и обычный промпт, и слэш-команду.

Интервал пишется человеческим сокращением: 5m, 30m, 1h. Режим без интервала стоит понимать буквально: агент выбирает паузу исходя из того, чего ждёт. Сборку, которая идёт восемь минут, он будет ждать одной паузой, а не восемью проверками по минуте.

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

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

Вызов заводит цикл и сразу возвращает управление: дальше он просыпается сам, и каждое пробуждение выглядит в сессии как обычный запрос.

/loop 5m /code-review low               # каждые пять минут — быстрая вычитка
/loop 1h проверь, не появились ли новые упавшие тесты, и почини очевидное
/loop проверяй, не сломалась ли сборка  # без интервала: темп выберется сам

/schedule [описание]

Создаёт, обновляет и запускает агента, который работает в облаке по расписанию. [не на всех тарифах] — нужен вход в аккаунт claude.ai: по ключу Console API, под профилем Anthropic и через Bedrock, Google Cloud и Foundry команды нет, там ближайшая замена — /loop. [сверх тарифа] — сами запуски идут в счёт обычного лимита тарифа, но у аккаунта есть дневной предел числа запусков: когда упираетесь в него или в лимит тарифа, продолжать можно только на подключённых кредитах, а без них лишние запуски отклоняются до сброса окна. Алиас: /routines. [Навык]

Отличие от /loop — место исполнения. /loop работает в вашей сессии, на вашей машине, пока она открыта. /schedule заводит задачу в облаке: она выполняется по расписанию независимо от того, включён ли ваш ноутбук.

Аргумент — описание словами, из которого выводится и расписание, и задача, и намерение: команда умеет не только создавать, но и обновлять, показывать, запускать вне очереди и удалять. Остальные требования те же, что у всего облачного: подключённый GitHub и отсутствие запрета от организации — на Team и Enterprise владелец может выключить расписания для всех. Окружение по умолчанию берётся из настройки remote. Вся функциональность помечена как исследовательская, то есть будет меняться.

Про расходы стоит помнить одно: запланированная задача просыпается и отправляет полный контекст, даже когда вы за компьютером и заняты своим. Это самая незаметная статья трат из всех.

Что окажется на экране, зависит от того, о чём вы попросили: все четыре вызова ниже — одна и та же команда, разбирающая ваше описание.

/schedule каждое утро в 9 собирай отчёт по упавшим тестам    # создать задачу
/schedule покажи мои запланированные задачи                  # что уже заведено
/schedule запусти утреннюю сводку прямо сейчас               # запуск вне расписания
/schedule удали задачу про зависимости                       # удалить

/autofix-pr [промпт]

Запускает облачную сессию, которая следит за pull request текущей ветки и сама пушит исправления — например, чинит упавшую сборку в CI. [не на всех тарифах] — работает через Claude Code в вебе, а для него нужен вход в claude.ai: по ключу API и через Bedrock, Google Cloud и Foundry облачных сессий нет. Необязательный аргумент сужает мандат: что править можно, а что трогать нельзя. Управление возвращается сразу — дальше сессия живёт в облаке сама, и смотреть на неё надо там.

/autofix-pr                                        # следить за PR и чинить падения CI
/autofix-pr правь только линтер, логику не трогай   # то же самое, но с ограничением

Артефакты, документы и дизайн

Артефакт — опубликованная на claude.ai страница, которую можно открыть, покликать и дать посмотреть коллегам. Почти всё ниже — встроенные навыки, и набор зависит от аккаунта: часть включается только для определённых подписок и организаций.

Публикация есть на Pro, Max, Team и Enterprise: на Team включена сразу, на Enterprise её включает владелец организации, а при CMEK, HIPAA или запрете на хранение данных она закрыта совсем. Нужна сессия с входом в claude.ai — по ключу API, токену шлюза и учётным данным Bedrock, Google Cloud и Foundry страница не опубликуется. Отдельно артефакты не тарифицируются: генерация страницы расходует выходные токены, как любой другой ответ.

В официальном справочнике команд из этой группы есть только /artifacts, /design, /design-login и /design-sync, остальные полтора десятка [нет в документации] — ни в чейнджлоге, ни в поиске, так что ниже то, что в сборке есть, а не то, что где-то обещано.

/artifacts

Показывает ваши опубликованные артефакты и те, которыми поделились с вами: название, ссылку, когда обновляли. [не на всех тарифах] — как и всё в этой группе, требует сессии с входом в claude.ai. Главное применение прикладное: найти ссылку на страницу, сделанную в прошлой сессии, — без неё Claude Code опубликует новую вместо того, чтобы обновить старую. Заодно это инвентарь: видно, что уже опубликовано и не потерялось ли.

Список интерактивный: на выбранной строке артефакт либо открывается в браузере, либо его ссылка копируется в буфер — уходить из терминала для этого не надо.

/prototype

Превращает идею в работающий прототип — одну самодостаточную страницу, которую можно открыть, потыкать и показать. [не на всех тарифах] — публикация требует входа в claude.ai. Берут, когда спорить словами дороже, чем посмотреть: экран интерфейса, поток из нескольких шагов, черновик лендинга. От дизайнерских команд ниже отличается тем, что делает работающую вещь, а не картинку.

Заранее ничего не спрашивают: вы описываете идею словами, дальше работа идёт до готовой страницы, и в конце остаётся ссылка на неё.

/prototype страница подбора тарифа: три плана, переключатель месяц-год, расчёт скидки

/doc

Публикует рабочий документ, который правится прямо на странице: заметка, памятка, инструкция для команды. [не на всех тарифах] — нужен тот же вход в claude.ai. Смысл в том, что документ не остаётся в переписке: у него есть адрес, его можно открыть, дописать и дать ссылку. Тянуться сюда стоит, когда результат нужен людям, а не вам одному в терминале.

Что за документ нужен, говорится прямо в команде; в ответ приходит адрес опубликованной страницы, и дальше её правят либо на самой странице, либо просьбой к агенту.

/doc собери из решений этого разговора памятку по деплою для дежурного

/plan-artifact

Публикует план отдельной страницей, которой можно поделиться: этапы, что за чем идёт, что от кого нужно. [не на всех тарифах] — публикация требует входа в claude.ai. Удобно, когда план, собранный в режиме планирования, надо показать людям, а не пересказывать. От /doc отличается только заготовкой: тут это план, а не произвольный документ.

Дальше вы уточняете, что должно быть в плане; результат — страница с этапами и ссылка на неё.

/artifact-pr-review [номер или ссылка]

Разбирает pull request и выкладывает разбор отдельной страницей: вывод, рекомендация, спорные места, слепые зоны. [не на всех тарифах] — публикация требует входа в claude.ai. Аргумент — номер PR или ссылка на него. Нужна, когда разбор надо показать автору и остальным; с /code-review не путать — та ищет дефекты и работает в терминале, а эта делает читаемую страницу с выводом.

Работа идёт в два приёма и не мгновенно: сначала PR читается целиком, и только потом публикуется страница, ссылку на которую вы и получаете.

/artifact-pr-review 1234

/artifact-dashboard

Собирает дашборд по готовому шаблону: показатели, графики, разрезы на одной странице. [не на всех тарифах] — публикация требует входа в claude.ai. Берут, когда есть цифры и их надо показать целиком: статус проекта, результаты прогона, метрики за период. Шаблон задаёт вёрстку и оформление — от вас данные и понимание, что здесь главное.

Дальше вы даёте данные и говорите, что в них главное; в конце остаётся ссылка на собранный дашборд.

/artifact-dashboard недельные метрики очереди: длина, время ожидания, доля повторов

/artifact-report

Отчёт по готовому шаблону: выводы сверху, разделы с подробностями ниже. [не на всех тарифах] — публикация требует входа в claude.ai. Годится для итогов аудита, разбора или большого прогона, когда результат надо передать людям целиком, а не пересказывать по кускам. Отличие от дашборда — здесь текст и рассуждение, а не плитки с цифрами.

Дальше вы говорите, о чём отчёт; результат — опубликованная страница и ссылка на неё.

/artifact-report итоги нагрузочного теста для смежной команды

/artifact-data-table

Публикует данные таблицей по готовому шаблону — отдельной страницей вместо простыни в терминале. [не на всех тарифах] — публикация требует входа в claude.ai. Нужна, когда строк больше, чем помещается в ответ, и по ним хочется походить глазами. Данные берутся из того, что вы дали или что собралось в этой сессии.

Дальше вы даёте строки и колонки; в конце — ссылка на страницу с таблицей.

/artifact-data-table таблица SLA по сервисам из последнего отчёта

/artifact-explainer

Страница-объяснение по готовому шаблону: разбор одной темы или механизма по шагам. [не на всех тарифах] — публикация требует входа в claude.ai. Берут, когда надо объяснить устройство чего-то коллеге или новому человеку в команде, и объяснение должно жить дольше одного разговора. От отчёта отличается задачей: отчёт сообщает результат, объяснение учит понимать.

Дальше вы называете тему; результат — страница с разбором и ссылка на неё.

/artifact-explainer как устроена наша схема идемпотентности заказов

/artifact-components

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

На экране после вызова ничего не появляется: набор компонентов просто оказывается в контексте.

/artifact-design

Правила оформления артефактов: вёрстка, типографика, тёмная тема и, что важнее, соразмерность усилий задаче. Загружают перед тем, как делать страницу, чтобы она выглядела как готовая вещь, а не как черновик из терминала. Ничего не публикует и не печатает.

/artifact-diagramming

Как рисовать схемы, которые показывают реальный механизм, а не набор коробок со стрелками: когда схема вообще нужна, что на ней должно быть и как сделать её читаемой в светлой и тёмной теме. Загружают, когда в артефакте нужна схема. Ничего не публикует и на экран не выводит.

/artifact-capabilities

Описывает, что опубликованная страница умеет в рантайме: читать ваши данные, запоминать действия посетителей (опрос, чеклист, документ, который правят прямо на странице), держать общее состояние, спрашивать Claude. Загружают до того, как просить такую страницу: без этого получится обычный статичный HTML, который ничего не помнит. Набор возможностей зависит от аккаунта, и команда показывает, что доступно именно вам.

/dataviz

Правила оформления графиков и дашбордов: какой тип графика к каким данным, палитры, оси, подписи, доступность, поведение в тёмной теме. Загружают до того, как написана первая строка кода графика, — переделывать потом дороже. Работает не только для артефактов: правила те же и для картинки, и для кода на любой библиотеке.

Сам вызов ничего не выводит: правила подгружаются и действуют на следующий график.

/whiteboard

Общая доска: вы рисуете от руки, а ответы приходят прямо на неё. [не на всех тарифах] — доска живёт опубликованной страницей, а значит нужен вход в claude.ai. Годится там, где объяснять словами дольше, чем накидать эскиз: расположение элементов, структура экрана, связи между кусками системы.

Доска открывается отдельной страницей, и ссылку на неё вы получаете в ответ на вызов.

/whiteboard набросай обмен между сервисом заказов и платежами

/whiteboard-mp

То же самое, но доска живая, и рисует на ней не только человек: агент добавляет своё поверх вашего, и получается работа вдвоём. [не на всех тарифах] — как и обычная доска, требует входа в claude.ai. Берут, когда нужно не «нарисовать и спросить», а набрасывать вместе.

Страница по устройству та же, со ссылкой в ответе; отличие в том, что дальше на одном полотне оказываются и ваши штрихи, и то, что дорисовал агент.

/whiteboard-mp разбираем вдвоём, где в этой схеме теряется идемпотентность

/workshop

Собирает дизайн вместе с вами, по одному решению за раз: вопрос — ваш ответ — следующий шаг, вместо большой страницы, сделанной сразу целиком. [не на всех тарифах] — результат публикуется, поэтому нужен вход в claude.ai. Годится, когда вы сами ещё не знаете, чего хотите, и решение выкристаллизовывается по ходу.

Разговор начинается с вопроса и идёт вопросами до конца; готовая страница со ссылкой появляется в самом финале.

/workshop экран настроек уведомлений — по одному решению за раз

/design [sync|login|consent|revoke|import|export|status|описание]

Хаб Claude Design — связки Claude Code с дизайн-системой на claude.ai. [не на всех тарифах] — есть на Pro, Max, Team и Enterprise (на Enterprise выключена по умолчанию), нужна сессия, где работают артефакты, и версия не ниже 2.1.234; на Bedrock, Google Cloud, Foundry и Claude Platform on AWS команды нет. Отдельно не тарифицируется: расход идёт в тот же общий лимит, что и обычная работа.

Официально это одна команда «с описанием дизайна», а /design-login и /design-sync — две отдельные. В бинарнике /design дополнительно понимает семь подкоманд, и это нигде не описано. Появилась вся история в версии 2.1.234 и помечена как исследовательская — то есть меняться будет.

Отвечают подкоманды по-разному: status сообщает состояние подключения, login уводит подтверждать доступ в браузер, а import и export переносят дизайн-систему между проектом и claude.ai.

/design status                           # состояние подключения к Claude Design
/design login                            # войти
/design import                           # забрать дизайн-систему оттуда
/design export                           # выгрузить туда

/design-sync [подсказка]

Собирает дизайн-систему React-проекта прямо из кода и выгружает её на claude.ai/design, чтобы всё, что там рисуется, выглядело как ваш продукт, а не как чужой шаблон. [не на всех тарифах] — те же требования, что у /design: вход в claude.ai и доступная публикация артефактов. Аргумент — короткая подсказка, как назвать выгрузку или на что смотреть в проекте. Если доступ ещё не выдан, начинать надо с /design-login.

Всё происходит в один заход и без вопросов: проект разбирается, дизайн-система собирается и уезжает на claude.ai/design — там её и смотрят.

/design-sync Acme DS

/design-login

Авторизует доступ к дизайн-системе — тот самый, что нужен для выгрузки. [не на всех тарифах] — работает там же, где и остальной Claude Design, и требует входа в аккаунт claude.ai. Вынесена отдельно, потому что вход делается один раз, а выгрузок потом много. Если /design-sync ругается на доступ, начинать надо отсюда, а проверить результат — через /design status.

Вход подтверждается в браузере; после этого доступ остаётся выданным, и повторять его перед каждой выгрузкой не нужно.

Конфигурация и интерфейс

/config [ключ=значение]

Панель настроек: без аргумента открывается панель со всеми настройками, которые можно менять из интерфейса. Это главная точка входа во всё поведение агента — от темы до модели и режимов работы, — и заглядывать сюда проще, чем помнить имена ключей в файле настроек. Алиас: /settings.

С аргументом настройка выставляется сразу, без панели: /config theme=dark. Полный список принимаемых ключей печатает /config --help — не угадывайте, он короче, чем список ключей файла настроек.

Прямая форма появилась в 2.1.181, именованные сокращения вроде theme и model — в 2.1.182. Работает она и в неинтерактивном режиме, и с телефона через удалённое управление, что делает её основным способом поменять настройку из скрипта.

Ограничение ровно одно, но неочевидное: форма «ключ=значение» не может включить настройку, которая требует вашего подтверждения в панели. Например autoContinueAtUsageLimit она умеет выключить, но не включить — включение сопровождается диалогом, а диалог в этой форме показать негде.

/config                  # открыть панель настроек
/config --help           # какие ключи принимает форма ключ=значение
/config theme=dark       # выставить сразу, без панели
/config model=sonnet     # то же для модели

/permissions

Правила разрешения и запрета инструментов, плюс вкладка авто-режима. Сюда идут в двух случаях: надоело подтверждать одну и ту же безобидную команду — или, наоборот, нужно закрыть агенту доступ к чему-то, чего он трогать не должен. Правило записывается в настройки и действует дальше само, без вопросов. Алиас: /allowed-tools.

Выбираете сначала список — разрешённое, запрещённое или требующее подтверждения, — а внутри него добавляете своё правило или снимаете лишнее; изменения действуют с этого момента, перезапуск не нужен.

/permissions   # правила прав доступа

/theme

Сменить цветовую тему интерфейса. Тема меняет только то, как Claude Code рисует себя в терминале — подсветку кода в дифах, рамки, выделения; на настройки самого терминала она не влияет.

Кроме светлой и тёмной есть варианты для дальтоников, ANSI-варианты для терминалов со своей палитрой и auto, подстраивающаяся под фон терминала. Свои темы кладутся в ~/.claude/themes/ или приходят из плагинов; прямо в выборе есть пункт создания новой.

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

/theme   # выбрать тему

/keybindings

Открыть или создать файл горячих клавиш — ~/.claude/keybindings.json. В нём переопределяются сочетания интерфейса, в том числе аккорды из двух нажатий подряд. Нужна, когда привычное сочетание перехватывает сам терминал или мультиплексор и до Claude Code оно просто не доходит. Файл открывается в редакторе; если его ещё не было, он создаётся.

/keybindings   # свои горячие клавиши

/terminal-setup

Настроить сочетания терминала — например Shift+Enter для переноса строки. Правки уходят в конфигурацию самого терминала, а не Claude Code: выполнить достаточно один раз на машине, но после переезда на другой терминал придётся повторить.

/terminal-setup   # Shift+Enter и прочие сочетания терминала

/statusline

Настроить строку состояния: своим скриптом или сгенерировать из вашего shell-промпта. Строка состояния — это то, что Claude Code печатает у поля ввода: обычно каталог, ветка и модель, но содержимое целиком ваше. Скрипт вызывается на обновление строки, и в неё попадает то, что он напечатал.

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

/statusline   # настроить строку состояния

/voice [hold|tap|off]

Голосовой ввод. [не на всех тарифах] — диктовка требует входа в аккаунт claude.ai: с API-ключом и у сторонних провайдеров её нет. Пригождается, когда надо надиктовать длинную постановку задачи, а не набирать её; режим выбирается по тому, как вам удобнее держать руки.

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

/voice hold   # говорить с зажатой кнопкой
/voice tap    # нажал — говоришь, нажал — отправил
/voice off    # выключить голосовой ввод

/tui [default|fullscreen]

Рендерер интерфейса: fullscreen — полноэкранный, без мерцания, default — обратно к обычному. Полноэкранный занимает окно целиком и перерисовывает себя сам, поэтому длинный вывод не дёргается. Обычный пишет в поток терминала, и историю листает сам терминал — если вы копируете куски вывода мышью или полагаетесь на прокрутку терминала, оставайтесь на нём.

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

/tui fullscreen   # полноэкранный рендерер без мерцания
/tui default      # обратно

# отказ в сессии с ограничениями, которые перезапуск не переносит
# (так это выглядит в документации):
Cannot switch renderers in this session — it has restrictions a restart can't carry over (permission rules set for this session only). Nothing was changed. Running /tui fullscreen in a session started without them switches every later session too.

/color [цвет|default]

Цвет строки промпта для текущей сессии. Это не тема, а именно цвет строки ввода; удобно, когда открыто четыре терминала и надо не перепутать.

Палитра фиксированная: red, blue, green, yellow, purple, orange, pink, cyan, плюс default для сброса. Если подключено удалённое управление, цвет синхронизируется и в веб-интерфейс.

/color purple    # цвет строки промпта
/color           # случайный цвет
/color default   # сбросить

/scroll-speed

Скорость прокрутки колесом мыши. Настройка чисто бытовая: по умолчанию колесо в длинной сессии либо ползёт, либо перепрыгивает нужное место, и здесь это правится. Команда открывает выбор скорости, а проверить результат можно тут же, колесом.

/scroll-speed   # скорость прокрутки колесом

/focus

Фокус-вид: на экране остаётся только ваш промпт, сводка инструментов и финальный ответ. Всё промежуточное — подробности вызовов, содержимое прочитанных файлов, длинный вывод команд — с экрана уходит. Нужен, когда сессия разрослась и за технической выдачей теряется сам разговор, а также когда вы показываете работу агента кому-то ещё.

/focus   # оставить только суть на экране

/hooks

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

/hooks   # какие хуки настроены

/auto-mode-setup

Рассказать авто-режиму про ваше окружение и подправить его правила. Авто-режим — это работа без подтверждения каждого шага, и по умолчанию он осторожничает просто потому, что ничего не знает про ваш проект. Команда проходит по окружению вместе с вами и превращает ответы в правила: что здесь можно делать молча, а что трогать нельзя ни при каких условиях.

/auto-mode-setup   # рассказать авто-режиму про окружение

/sandbox [exclude "шаблон"|install]

Настроить песочницу для команд. Песочница ограничивает, куда запущенная команда может писать и ходить по сети, и именно она позволяет выполнять рутину, не подтверждая каждый вызов. Команда видна только там, где песочница поддерживается.

exclude — это тот случай, когда сборка или контейнерная команда не работает внутри изоляции и вы сознательно её оттуда достаёте; список копится в ключе sandbox.excludedCommands.

/sandbox                      # панель песочницы
/sandbox exclude "docker *"   # вывести команду из песочницы
/sandbox install              # доустановить песочницу (Windows)

/import [codex|gemini] [--dry-run] [--yes]

Перенести конфигурацию из другого кодинг-агента: файлы инструкций, MCP-серверы, команды, субагентов и навыки. [не на всех тарифах] — недоступна на сторонних провайдерах и при выключенной подгрузке серверных флагов. Поддерживаются codex и gemini.

В неинтерактивном режиме команда печатает, что нашла, и подсказывает строку для подтверждения импорта. Требует версии 2.1.213 и новее.

Важно, чего /import не делает: файл AGENTS.md, который используют некоторые другие агенты, Claude Code сам по себе не читает — но /import умеет перенести конфигурацию оттуда в понятный ему вид.

Без --yes выбор остаётся за вами: команда показывает найденное по видам и спрашивает, что именно тащить, — можно взять только MCP-серверы, а команды и навыки оставить как есть.

/import codex              # забрать конфигурацию другого агента
/import gemini --dry-run   # посмотреть, что перенеслось бы
/import codex --yes        # перенести без вопросов

/cloud-plugins

Использовать ли в облачных сессиях плагины, включённые на этой машине. [не на всех тарифах] — сами облачные сессии требуют входа через аккаунт claude.ai и недоступны с API-ключом и у сторонних провайдеров. Облачная сессия запускается на чужой машине, где вашего набора плагинов нет: настройка решает, тянуть его туда или обходиться тем, что в Claude Code встроено.

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

/cloud-plugins   # плагины в облачных сессиях

/skills

Список навыков с управлением их видимостью.

Описания всех доступных навыков висят в контексте постоянно, каждую сессию, независимо от того, пользуетесь вы ими или нет. На большом наборе плагинов это ощутимая доля окна — экран /skills для того и нужен.

Печатаете — список фильтруется по имени, описанию и источнику. Клавиша t сортирует по числу токенов, и вот тут обычно и обнаруживается, что половину окна занимают три навыка, которыми вы не пользовались ни разу. Space или Enter переключает видимость навыка для модели и для меню, Esc сохраняет и закрывает.

Переключить получится не всё: плагинные навыки, навыки с disable-model-invocation: true во frontmatter и те, для которых видимость задана в корпоративных настройках или через --settings, не поддаются. Постоянный эквивалент — ключ skillOverrides, а найти то, что просто не используется, помогает /skill-doctor.

/skills   # список навыков и их видимость

/plugin

Управление плагинами и маркетплейсами. Маркетплейс — источник, из которого плагины ставятся; сам плагин приносит с собой команды, навыки, субагентов, хуки и MCP-серверы разом, поэтому один плагин может заметно поменять поведение сессии. Через эту панель маркетплейс подключается, а плагин ставится, выключается и удаляется. Алиасы: /plugins, /marketplace.

Порядок выбора такой: сначала маркетплейс, потом плагин внутри него. Часть изменений вступает в силу не мгновенно — их добивает /reload-plugins.

/plugin   # плагины и маркетплейсы

/reload-skills

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

/reload-skills   # подхватить изменения навыков с диска

/reload-plugins [--force]

Активировать отложенные изменения плагинов — то же, что /reload-skills, только для плагинов. Пригождается сразу после /plugin, когда плагин уже поставлен, но сессия его ещё не видит.

Смысл --force тут противоположен интуитивному: это не «перечитать глубже». Если перезагрузка изменит набор загруженных MCP-инструментов, она обнулит кэш промпта, и команда, предупредив, откажется её делать — а --force заставляет сделать всё равно. То есть флаг преодолевает отказ, а не углубляет работу.

/reload-plugins           # применить отложенные изменения плагинов
/reload-plugins --force   # то же, даже если это сбросит кэш промпта

MCP и интеграции

/mcp [reconnect|enable|disable [<сервер>|all]]

Управление MCP-серверами и их OAuth-авторизацией. MCP-сервер — внешний процесс или сервис, который приносит в сессию свои инструменты, промпты и ресурсы: трекер задач, база, браузер, внутренний API. Сюда идут, когда сервер отвалился посреди работы, когда он просит войти заново или когда его инструменты сейчас только мешают — лишний сервер лучше выключить, чем держать его описания в контексте. Сами серверы описываются в конфигурации, здесь только их текущее состояние.

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

Серверы отдают свои промпты как команды. Они появляются в меню в виде /имя-сервера:имя-промпта — и это форма, которую стоит запомнить, потому что вторая, /mcp__сервер__промпт, работает тоже, но встречается только в старых статьях. Аргументы передаются через пробел и режутся по пробелам: каждый аргумент — один токен, фразу в кавычках как один аргумент передать не выйдет.

Ресурсы сервера подтягиваются через @. Форма — @сервер:протокол://путь, и это отдельный от инструментов механизм: не «позови инструмент», а «положи содержимое в контекст».

В фоновой сессии, к которой не подключён терминал, панель не откроется вовсе: сессия перейдёт в состояние «нужен ввод», а управлять серверами предложат формой /mcp enable|disable|reconnect <сервер>.

/mcp                                     # список серверов и их состояние
/mcp reconnect github                    # поднять упавший сервер
/mcp disable jira                        # временно выключить сервер
/jira:create_issue login-bug high        # промпт сервера, нынешняя форма

/ide [open]

Интеграции с IDE и их статус. Из-за этой связи правки видно в редакторе как диффы, а выделенный там фрагмент попадает в контекст, поэтому первое, куда идут при «в редакторе ничего не происходит», — сюда: обычно окажется, что связь не установилась. Без аргумента показывает статус интеграции с редактором, с open — открывает файл в подключённой IDE.

/ide                                     # статус интеграции с редактором
/ide open                                # открыть файл в подключённой IDE

/chrome

Настройки Claude in Chrome. [не на всех тарифах] Расширение работает только при входе в аккаунт claude.ai — с ключом API и у сторонних провайдеров его нет. Claude in Chrome — это когда агент ходит по страницам вашего же браузера: кликает, читает страницу, смотрит консоль. Разрешения выдаются по сайтам, и без них не выполнится ничего, поэтому сюда заглядывают перед первой браузерной задачей.

/chrome                                  # настройки работы в браузере

Аккаунт и авторизация

/login

Войти в аккаунт Anthropic или переключить аккаунт. Здесь же выбирается, чем оплачивается работа — подпиской claude.ai или ключом API из Console, и от этого зависит не только счёт: часть возможностей (веб-сессии, мобильное приложение, кредиты сверх тарифа) есть только на подписке. Вход происходит в браузере, после подтверждения управление возвращается в терминал.

Сюда же отправляют сообщения о том, что войти надо заново: Not logged in · Please run /login, OAuth token revoked · Please run /login, OAuth token has expired · Please run /login — все три приведены в документации дословно.

/login                                   # войти или переключить аккаунт

/logout

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

/logout                                  # выйти

/setup-bedrock

Настроить Amazon Bedrock: авторизация, регион, пины моделей. Нужна там, где работа идёт не через Anthropic напрямую, а через AWS — обычно из-за требования держать трафик в своём облаке. Видна при включённом Bedrock.

Вместе с /setup-vertex это пример команд, скрытых по состоянию: они появляются только тогда, когда выставлена соответствующая переменная окружения провайдера. Пока её нет, их нет и в /help.

/setup-bedrock                           # настроить Amazon Bedrock

/setup-vertex

Настроить Google Cloud: авторизация, проект, регион, пины моделей. Смысл тот же, что у Bedrock: трафик идёт через ваше облако и оплачивается там же. Как и /setup-bedrock, видна только при выставленной переменной окружения провайдера.

/setup-vertex                            # настроить Google Cloud

/install-github-app

Установить Claude GitHub Actions для репозитория. Это приложение, через которое разбор pull request'ов происходит на стороне GitHub, а не в вашем терминале. Ставится один раз на репозиторий; локальный /code-review от него не зависит и работает без всякой установки.

/install-github-app                      # поставить ревью в CI на репозиторий

/install-slack-app

Установить Slack-приложение. [не на всех тарифах] Claude Code в Slack требует входа в claude.ai — с ключом API и у сторонних провайдеров недоступен. После установки задачу можно поставить прямо из переписки, и ответ придёт туда же — удобно там, где обсуждение и так идёт в Slack. В корпоративном пространстве установка может упереться в права администратора.

/install-slack-app                       # поставить приложение в Slack

/privacy-settings

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

/privacy-settings                        # что уходит наружу

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

/usage

Стоимость сессии, использование лимитов тарифа и статистика активности. Алиасы: /cost, /stats. Сюда идут в двух случаях: когда надо понять, доживёте ли до сброса лимита, и когда расход вдруг вырос и надо увидеть, кто его создаёт.

Экран показывает три вещи: сколько потрачено в этой сессии, насколько заполнены лимиты тарифа и на что уходят токены — с разбивкой по навыкам, субагентам, плагинам и отдельным MCP-серверам, плюс пометки о поведении, дающем больше десяти процентов расхода. Клавиши d и w переключают окно между сутками и неделей, а запланированные задачи с 2.1.242 получают свои строки.

Дальше — четыре вещи, которые важно понимать, и ни одна из них не очевидна.

Разбивка считается по локальной истории сессий. То есть по транскриптам на этой машине. Работа с другого компьютера и из веб-интерфейса в неё не попадает — при том что сами лимиты общие на аккаунт. Расхождение между «я почти ничего не потратил» и «лимит на исходе» обычно объясняется именно этим.

Лимитов несколько, и переключение модели помогает только от одного. Сообщения «вы исчерпали лимит сессии» и «вы исчерпали недельный лимит» относятся к окнам, общим для всех моделей, — /model тут не спасёт. И только после «вы исчерпали лимит Opus» или «лимит Sonnet» переход на модель другого семейства вернёт вас в работу. С версии 2.1.234 Claude Code умеет подождать сброса и продолжить прерванную задачу сам; включается это через /rate-limit-options и ключ autoContinueAtUsageLimit.

Кэш промпта живёт час только на подписке. Как только вы начинаете тратить кредиты сверх тарифа, время жизни кэша падает с часа до пяти минут — и та же самая пауза на обед, которая вчера ничего не стоила, сегодня оборачивается переработкой всего контекста заново. На ключе API и у облачных провайдеров пять минут по умолчанию.

Счётчик сессии обнуляется на /clear. До версии 2.1.211 он копился через очистки, и цифры из старых статей с нынешними не сходятся.

Если сервер лимитов недоступен, экран покажет последние загруженные данные с пометкой и предложит повторить по клавише r. Пока подключены кредиты сверх тарифа, для них здесь есть отдельная строка.

Незаметные статьи расхода, которые не видны в разбивке, но реально жгут лимит, пока вы ничего не делаете: запланированные задачи просыпаются и уходят с полным контекстом; сообщение от другой вашей сессии приходит как новый ход (лечится crossSessionInbound: "hold"); проверки активной цели начинают ходы, пока фоновая работа идёт; каждый живой тиммейт тратит, пока не завершится. И /compact — сам по себе крупный запрос, тогда как /clear не стоит ничего.

/usage                                   # лимиты, расход, разбивка
# вывод целиком, как его привёл автор отчёта об ошибке
Session
Total cost:            $86.94
Total duration (API):  1h 31m 17s
Total duration (wall): 1d 22h 35m
Total code changes:    2538 lines added, 312 lines removed
Usage by model:
    claude-opus-4-8:   9.0k input, 461 output, 50.4k cache read, 29.9k cache write ($0.3802)
    claude-haiku-4-5:  2.0k input, 43 output, 0 cache read, 0 cache write ($0.0022)
    claude-sonnet-5:   86.5k input, 448.0k output, 197.4m cache read, 3.4m cache write ($86.55)

Current session: 17% used, resets 1:29pm (Europe/Madrid)
Current week (all models): 19% used, resets Aug 13 at 8:59am (Europe/Madrid)
# отдельной строкой там же, начиная с 2.1.251, — про кэш промпта; так это выглядит в документации
Prompt cache (main):   14 requests · 91% of input tokens from cache · 2 misses (last 6m 10s ago, 310.2k tokens re-cached) · 1 expected rebuild (compaction or tool-result clearing) · warm (1h TTL, last activity 40s ago)

/stats                                   # то же, сразу на вкладке статистики
/cost                                    # то же, обычным видом

/usage-credits

Настроить кредиты, чтобы продолжать работу при достижении лимита тарифа. [не на всех тарифах] Команда работает только после входа под подпиской claude.ai через /login; с авторизацией по ключу API её нет. Кредиты — это оплачиваемый сверх подписки расход по обычным ставкам API, счёт за них отдельный от тарифа. Без них при исчерпанном лимите вы просто ждёте сброса окна; с ними придёт предложение продолжить, и дальнейшая работа пойдёт за деньги.

Куда именно уводит команда, зависит от вашей роли: подписчика Pro или Max — на страницу расхода в claude.ai, участника Team или Enterprise с доступом к биллингу — в админские настройки, а участника без такого доступа она попросит подтвердить и отправит запрос администраторам организации. На самой странице выбирают три вещи: включить кредиты или нет, поставить месячный потолок трат или снять его, и пополнить баланс. У подписавшихся через мобильное приложение включение и пополнение работают только в веб-версии.

Помните про побочный эффект, описанный выше: с началом трат сверх тарифа кэш промпта живёт пять минут вместо часа.

/usage-credits                           # подключить кредиты сверх тарифа

Удалённая работа и окружения

/desktop

Продолжить текущую сессию в desktop-приложении. [не на всех тарифах] Приложению нужен вход в claude.ai — на ключе API и у сторонних провайдеров его нет. Сессия переезжает вместе с контекстом и историей: задачу не надо ставить заново. Пригодится, когда работу удобнее продолжать в окне приложения, а не в терминале. Алиас: /app.

/desktop                                 # продолжить в приложении

/teleport

Втянуть веб-сессию в этот терминал. [не на всех тарифах] Веб-сессии — research preview для Pro, Max и Team (на Enterprise нужен подходящий тип места), требуют входа в claude.ai и недоступны на Bedrock, Google Cloud и Microsoft Foundry. Контекст, история и состояние работы переезжают к вам, и дальше вы работаете локально — это нужно, когда задачу поставили с телефона или из браузера, а доводить её удобнее руками. Выбирают из своих активных веб-сессий; после выбора терминал продолжает ту, что вы указали. Отдельной платы за облачную машину нет, расходуются обычные лимиты аккаунта. Алиас: /tp.

/teleport                                # забрать веб-сессию в терминал

/remote-control

Открыть сессию для управления с телефона или из веба. [не на всех тарифах] Требует входа в claude.ai; с ключом API недоступно. Работа при этом остаётся на вашей машине — снаружи вы только шлёте запросы и читаете ответы, поэтому доступ к репозиторию и окружению никуда не уезжает. Удобно, когда запущено что-то долгое и хочется следить за ним, не сидя за столом. Алиас: /rc.

Отказ выглядит понятно: если сессия работает не через api.anthropic.com, команда прямо называет причину и говорит, какую переменную окружения снять.

/remote-control                          # открыть сессию для телефона
# отказ при выставленной CLAUDE_CODE_USE_BEDROCK — так это выглядит в документации
Remote Control is only available when using Claude via api.anthropic.com. CLAUDE_CODE_USE_BEDROCK is set, so this session is using Amazon Bedrock — unset it (or run in a shell without it) to use Remote Control.

/session

Показать адрес удалённой сессии и QR-код для неё. Нужна после /remote-control, когда ссылку потеряли или подключаете второе устройство: телефоном проще навести камеру, чем переносить адрес руками. Работает там же, где и удалённое управление, — то есть при входе в claude.ai. Алиас: /remote.

/session                                 # адрес сессии и QR-код

/remote-env

Окружение по умолчанию для веб-сессий и телепорта. Смысл в том, чтобы облачная машина стартовала уже готовой к вашему проекту, а не пустой: иначе первая же сборка или прогон тестов спотыкается. Настраивается один раз и дальше применяется ко всем новым веб-сессиям. Касается только веба, которому нужен вход в claude.ai.

/remote-env                              # окружение по умолчанию для веба

/web-setup

Подключить GitHub к Claude Code в вебе через локальный gh. То есть отдать наружу доступ, который на вашей машине уже настроен, вместо отдельной авторизации в браузере. Делается один раз; без этого веб-сессия не увидит приватные репозитории. Как и всё веб-направление, требует входа в claude.ai.

/web-setup                               # подключить GitHub к вебу
# так это выглядит в документации
Connected as <your-github-username>

Диагностика и помощь

/help

Справка и список доступных команд. Список собирается под вашу сессию: команды, скрытые по состоянию (вроде настройки облачных провайдеров) или выключенные администратором, в нём не появятся — поэтому это честный ответ на вопрос «что у меня вообще есть», в отличие от документации. Хорошая проверка после установки плагина: его команды должны появиться здесь.

/help                                    # что вообще доступно

/status

Версия, модель, аккаунт, связь с API и статусы инструментов. Первое место, куда идут, когда поведение не сходится с ожиданиями: не та модель, не тот аккаунт, не доехавшая настройка. Работает даже во время ответа.

Открывает панель настроек на вкладке состояния. Кроме версии, модели, аккаунта и связи там есть строка вида сессии: interactive для обычной, background job · attached или background job · unattended для фоновой — в зависимости от того, подключён ли к ней терминал. Строка появилась в 2.1.221.

Плюс с 2.1.243 там же строка о пропущенных источниках корпоративных настроек: если админ положил файл политики, а действует другой, более приоритетный, здесь будет видно, какой именно проигнорирован. Это первое, что стоит смотреть, когда «настройка от админа не доехала».

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

/status                                  # версия, модель, аккаунт, связь
# строки вкладки состояния, как их привёл автор отчёта об ошибке (сборка 2.1.199)
Version: 2.1.199
Session ID: 352ea81c-819d-4028-bba5-daef515d0815
Login method: Claude Enterprise account
…
Model: claude-fable-5[1m] (claude-fable-5)
Setting sources: User settings, Enterprise managed settings (remote)

/doctor

Диагностика установки и приведение конфигурации в порядок. Алиас: /checkup. Сюда идут, когда CLAUDE.md разросся и каждый запрос тащит килобайты инструкций или когда после обновления что-то ведёт себя странно.

С версии 2.1.205 это не экран с отчётом, а полноценный навык, который правит вашу конфигурацию. Что он делает: вычищает дубли между локальным и закоммиченным CLAUDE.md; урезает закоммиченный, выбрасывая то, что агент и так выведет из кода; переносит вечно загруженные инструкции в навыки и вложенные файлы, подгружаемые по требованию; предлагает сделать авто-режим режимом по умолчанию и заранее одобрить безопасные команды, которые вы чаще всего запрещали. Сначала показывает находки, потом меняет.

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

Терминальный claude doctor — это по-прежнему диагностика без правок и без запуска сессии; читает файлы настроек в текущей папке, не спрашивая доверия к ней.

Команда остаётся доступной, даже если встроенные навыки отключены целиком: она специально помечена как переживающая disableBundledSkills. Спрятать её можно переменной DISABLE_DOCTOR_COMMAND или записью "doctor": "off" в skillOverrides.

/doctor                                  # проверить и починить конфигурацию

/feedback [отчёт]

Отправить отзыв о Claude Code. Текст можно передать прямо в аргументе или написать в открывшемся поле. Годится для «работает не так, как ожидалось» и для пожеланий; для конкретной поломки с приложенным разговором есть /bug.

/feedback                                # отправить отзыв
/feedback правки применяются, но не показываются в диффе

/bug [отчёт]

Сообщить об ошибке или поделиться разговором. Ею же пользуются, когда надо просто отдать кому-то ход сессии целиком. Прежде чем прикладывать разговор, стоит вспомнить, что в нём: имена внутренних сервисов, куски приватного кода и всё, что попало в контекст, уйдут вместе с ним. Алиас: /share.

Перед отправкой команда спрашивает, прикладывать ли разговор.

/bug                                     # сообщить об ошибке

/heapdump

Снять дамп памяти — для диагностики её высокого потребления. Скрытая.

Пишет снимок памяти и разбор потребления на рабочий стол (в домашнюю папку на Linux без рабочего стола). Команда скрыта не флагом сервера, а тем, что не показывается в меню: набирается целиком и работает. Важное предупреждение: при обращении в поддержку прикладывайте только файл с разбором, а сам снимок содержит весь ваш разговор и учётные данные, и делиться им нельзя.

/heapdump                                # дамп памяти на рабочий стол

/insights

Отчёт-анализ ваших сессий: зоны проекта, паттерны работы, точки трения. Это взгляд на привычки, а не на деньги — сколько потрачено, показывает /usage. Смотреть имеет смысл раз в несколько недель: из отчёта обычно вылезает то, что давно пора вынести в CLAUDE.md или в навык.

За один прогон разбирается до двухсот ещё не виденных сессий, совсем короткие пропускаются. Если что-то осталось за бортом, в шапке отчёта рядом с разобранным числом стоит общее — например, 200 sessions (412 total).

/insights                                # анализ моих сессий

/skill-doctor

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

/skill-doctor                            # какие навыки зря висят в контексте

/explain-usage

Куда ушли токены этой сессии, человеческим языком. [Навык] В отличие от /usage, где цифры и разбивка, здесь получается разбор с выводами: какие ходы вышли дорогими и почему. Полезно, когда лимит тает быстрее ожидаемого, а по таблице непонятно, что именно с этим делать.

/explain-usage                           # куда ушли токены

/install [версия] [--force]

Поставить нативную сборку прямо из сессии — без пакетного менеджера и без выхода в терминал. Пригодится, чтобы перейти с npm-установки на нативную или откатиться на конкретную версию, когда свежая сломала что-то важное. Аргумент — версия: stable или конкретный номер; --force ставит её поверх текущей.

/install stable                          # поставить стабильную сборку
/install 2.1.236 --force                 # конкретную версию, поверх текущей

Информация и документация

/release-notes

Список изменений по версиям: что появилось, что починили, что выключили. Читать стоит после каждого обновления — заметная часть поведения Claude Code меняется от сборки к сборке, и «вчера работало» чаще всего объясняется именно здесь.

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

/release-notes                           # что изменилось по версиям

/powerup

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

/powerup                                 # короткий урок по возможностям

/mobile

QR-код для установки мобильного приложения. Приложение нужно ради работы вне рабочего места: поставить задачу в дороге и посмотреть, чем кончилось. Алиасы: /ios, /android.

/mobile                                  # QR-код мобильного приложения

/radio

Lo-fi радио Claude FM в браузере. Ровно то, чем кажется: фоновая музыка, к работе агента отношения не имеет.

/radio                                   # фоновая музыка

/passes

Поделиться бесплатной неделей с друзьями и получить кредиты. Команда видна не всем: она появляется только у аккаунтов, которым это доступно, — так что в чужом /help её может не быть.

/passes                                  # поделиться бесплатной неделей

/upgrade

Перейти на Max: выше лимиты, больше Opus. Обычно сюда попадают прямо из сообщения об исчерпанном лимите. Если упирается не тариф, а конкретная модель, сначала дешевле попробовать /model — смена семейства модели снимает как раз этот случай.

/upgrade                                 # перейти на Max

/stickers

Заказать наклейки. К работе агента отношения не имеет: открывается форма заказа.

/stickers                                # заказать наклейки

/team-onboarding

Сгенерировать онбординг-гайд для команды из вашей истории использования. Смысл — не писать такой документ с нуля: он собирается из того, как вы работаете на самом деле, а не из общих советов. На выходе текст, который правят руками и кладут в репозиторий.

/team-onboarding                         # гайд для команды из моей истории

Убранные и выключенные команды

Своих разделов у них нет — набирать их незачем. Таблица нужна затем, что половина статей в интернете всё ещё их советует, и когда команда «не работает», проще всего посмотреть здесь.

Убраны совсем:

Выключены изнутри в сборке 2.1.251: зарегистрированы, но не работают и в меню не показываются.

Есть ещё команды, которые появляются по состоянию и которых вы не увидите, пока состояние не наступит: /limit-reset и /low-priority — когда вы упёрлись в лимит сессии, /rate-limit-options, /pro-trial-expired, /design-consent и /design-revoke, а /setup-cowork живёт только в режиме Cowork. Плюс два совсем внутренних входа, __remote-workflow и workflow-launch-exec, через которые сервер передаёт сессии готовый воркфлоу.

И отдельная категория — навыки только для модели: keybindings-help, memory-types, cowork-plugin. Агент подтягивает их сам, набрать их нельзя. Механизм общий и доступен вам тоже — это поле user-invocable: false во frontmatter навыка.

Два живучих заблуждения напоследок. Команды /alias не существует: под этим именем в бинарнике лежит описание системной утилиты alias для автодополнения команд, вводимых через !. И файла .claudeignore тоже не существует — чтобы агент игнорировал файлы, используйте .gitignore, который учитывается по умолчанию, или .ignore.

Как меню ищет команду

Мелочь, экономящая нервы. С версии 2.1.236 подсветка в меню срабатывает, если буквы после / совпадают с именем команды или её алиасом — с начала имени или с начала слова внутри него, причём разделители :, _ и - при сравнении игнорируются. Поэтому /adddir подсвечивает /add-dir, а /new подсвечивает /clear через его алиас.

Что изменилось тогда же и важнее: опечатка больше не угадывается. Раньше Enter на несуществующей команде запускал похожую. Теперь после опечатки ничего не подсвечено, близкие варианты остаются в списке и выбираются стрелками или Tab, но Enter отправит ваш текст как есть и сообщит о неизвестной команде.

Недоступные команды из меню просто исчезают — вы увидите «нет команд по такому запросу». Некоторые вместо этого отвечают своим сообщением о недоступности: например /schedule на ключе API скажет, что требует аккаунта. И частичным именем скрытую команду не вытащить — её надо набрать целиком.

Свои команды

Своя слэш-команда — это файл SKILL.md в папке навыка. Раньше для этого была отдельная сущность в .claude/commands/; сейчас команды и навыки слиты в одно, старые файлы продолжают работать и дают ровно такую же команду.

Где искать и куда класть:

Имя команды берётся из имени папки, а не из поля name. Для личных и проектных навыков name — только подпись в списке. У плагинных наоборот: name заменяет последний сегмент, и my-plugin/skills/review/ с name: fancy даёт /my-plugin:fancy. Короткая форма /fancy тоже сработает, если имя больше никем не занято.

Простейший пример:

---
name: fix-issue
description: Разобрать issue по номеру, найти причину и предложить правку
argument-hint: <номер issue>
allowed-tools: Bash(gh issue view:*), Bash(gh pr create:*)
---

Возьми issue номер $0 из этого репозитория.

Текущее состояние ветки:

!`git status --short`

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

Вызывается как /fix-issue 4821. Здесь $0 — это первый аргумент, то есть 4821, а строка с ! выполняется до того, как текст дойдёт до модели, и подменяется своим выводом. Про то и другое подробно ниже.

Поля frontmatter

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

Три ограничения, на которых спотыкаются. Frontmatter читается, только если открывающие --- стоят первой строкой файла. Поля description и when_to_use в листинге обрезаются до полутора тысяч символов — всё, что длиннее, модель при выборе навыка не увидит. И в старых файлах из .claude/commands/ работает тот же frontmatter, кроме name и paths — они там игнорируются.

Отдельно про allowed-tools: это предварительное одобрение на один ход, а не ограничение. Разрешение снимается с вашим следующим сообщением, хотя содержимое навыка остаётся в контексте. И у него есть неприятное свойство, о котором стоит знать всем, кто запускает агента в чужом репозитории: доверие к папке его не сдерживает. Проектный навык применит свой allowed-tools и в папке, которую вы никогда не помечали доверенной, включая неинтерактивный запуск. То есть навык, лежащий в репозитории, может выдать себе широкие права — читайте это поле в чужих репозиториях до запуска.

Аргументы: нумерация с нуля

Самое неожиданное место во всей теме, и его стоит запомнить дословно.

Да, $0 — это первый аргумент, а не имя команды, как в оболочке. Ошибка на единицу здесь — самая частая.

Индексированные аргументы разбираются с учётом кавычек: в /my-skill "hello world" second значение $0 — это hello world целиком. Индексированная подстановка, для которой аргумента не хватило, остаётся в тексте как есть; именованная превращается в пустую строку. Значение аргумента, внутри которого сам оказался $1 или $ARGUMENTS, вставляется буквально и второй раз не разворачивается. Экранирование — одним обратным слэшем: \$1.00. И если ни одна подстановка в теле не получила аргументов, строка ARGUMENTS: <значение> просто допишется в конец.

Встроенные команды оболочки

Запись !`команда` выполняется до того, как содержимое попадёт к модели, и заменяется своим выводом. Так в навык подставляют актуальное состояние: ветку, дифф, список упавших тестов. Чем именно её выполнять — bash или powershell — задаётся полем shell во frontmatter.

Есть два правила, которые экономят полчаса недоумения. Форма распознаётся, только если ! стоит в начале строки или сразу после пробела — в KEY=!`cmd` она останется текстом и не выполнится. И подстановка проходит по файлу один раз: вывод команды повторно не сканируется, поэтому команда не может напечатать другую подстановку в расчёте на второй проход.

Для многострочного скрипта открывают блок кода с восклицательным знаком после трёх обратных кавычек.

Выключается всё это ключом disableSkillShellExecution: каждая команда заменяется заглушкой о запрете политикой. Действует на пользовательские, проектные, плагинные навыки и навыки из добавленных папок; встроенные и корпоративные не трогает. Навыки, синхронизированные с claude.ai, такие команды локально не выполняют никогда, независимо от настройки.

Переменные путей

Внутри тела навыка и внутри правил allowed-tools подставляются ${CLAUDE_SKILL_DIR} — папка самого навыка, ${CLAUDE_PROJECT_DIR} — корень проекта, ${CLAUDE_SESSION_ID}, а в плагинных навыках ещё ${CLAUDE_PLUGIN_ROOT} и ${CLAUDE_PLUGIN_DATA}.

То, что они работают в обоих местах, — не мелочь, а рабочий приём: так навык запускает свой собственный скрипт без единого вопроса о правах.

---
name: render
description: Отрисовать схему из исходника
allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/render.sh *)
---

Запусти `${CLAUDE_SKILL_DIR}/scripts/render.sh $0` и покажи результат.

Правило разрешает ровно ту команду, которую тело велит выполнить, — ни шире, ни уже.

Мелочи, которые полезно знать

Навыки стыкуются. В начале одного сообщения можно поставить до шести команд: /write-tests /fix-issue 123 загрузит оба навыка и передаст обоим 123 как аргументы. До версии 2.1.199 загружался только первый, а остальное считалось текстом. Исключение — /code-review, которая забирает остаток строки себе.

ultrathink в теле навыка просит модель думать глубже, когда навык срабатывает. Работает прямо словом в тексте.

Имена встроенных команд зарезервированы, даже если в вашей сессии они недоступны: навык с конфликтующим именем, приехавший из синхронизации, будет пропущен.

Проверить навык можно без плагина: claude plugin validate <путь> работает и на обычной папке с навыками и агентами. А чтобы папка с навыками стала плагином, достаточно положить в неё .claude-plugin/plugin.json.

Настройки: settings.json

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

Обозначения: [эксп] — экспериментальный или внутренний ключ, может измениться или исчезнуть; [админ] — действует только из корпоративного источника; [устар] — устаревший; [глобальный] — живёт не в settings.json, а в ~/.claude.json.

Где лежит файл

Уровней не четыре и не пять, а больше, чем принято писать. Начнём с обычных:

Последняя строка — то, чего нет почти нигде. Часть настроек живёт только в ~/.claude.json, и если написать их в settings.json, они будут молча проигнорированы. Туда же Claude Code складывает вашу сессию входа, конфигурацию MCP-серверов и решения о доверии к папкам. Обычно этот файл пишется сам, руками в него лезут редко — но знать про него надо, потому что «я выставил ключ, и ничего не произошло» чаще всего объясняется именно этим.

Корпоративная политика тоже не одна. Источников четыре, и они ранжированы:

Политика из системы и HKCU перечитываются каждые полчаса, серверные настройки — раз в час. По умолчанию источники не складываются: применяется самый старший, остальные отбрасываются. Изменить это можно ключом managedSourcesBehavior: "merge", но задать его надо в самом старшем из развёрнутых источников — нижний не может сам напроситься в слияние, а HKCU не сливается никогда.

Если админ что-то положил, а оно «не доехало» — смотрите в /status: с версии 2.1.243 там есть строка о пропущенных источниках, где прямо написано, какой файл проигнорирован.

Формат: строгий JSON

Тут я должен исправить сам себя, потому что раньше думал иначе и в интернете это повторяют часто.

Файлы настроек — строгий JSON. Комментарий // или висячая запятая — синтаксическая ошибка, и при следующем запуске файл будет помечен как ошибочный целиком. Никакого JSONC. (Путаница возникает потому, что JSONC в продукте действительно есть в других местах — например, /terminal-setup разбирает конфигурацию редактора с комментариями.)

Проверить свой файл проще всего запуском: ошибки настроек печатаются на старте. claude doctor покажет их разбором.

Полезная привычка — строка $schema:

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json"
}

Редактор начнёт подсказывать имена ключей и подчёркивать опечатки, а опечатка в имени ключа — самая частая причина того, что настройка «не работает»: неизвестные ключи молча игнорируются. Оговорка: схема иногда отстаёт от продукта. Например teammateDefaultModel в ней ещё есть, а из Claude Code он убран в 2.1.234 и ни на что не влияет.

Кто кого перекрывает

Порядок уровней — тот, что в таблице выше. Но «перекрывает» верно не для всего, и вот три исключения, которые ломают интуицию.

Списки складываются, а не заменяются. Если permissions.allow задан и в пользовательском файле, и в проектном, вы получите объединение обоих. Верхний уровень не может убрать запись нижнего — единственное, что это умеет, корпоративный allowManagedPermissionRulesOnly. Любая таблица приоритетов, где написано «каждый следующий перекрывает предыдущий», для списков неверна.

Четыре списка ведут себя иначе: fallbackModel берётся целиком из самого старшего файла, который его определяет (это упорядоченная цепочка, смешивать её бессмысленно); modelPicker — целиком из старшего среди корпоративного, --settings и пользовательского, а в проектном и локальном игнорируется; availableModels от админа применяется как есть, не подхватывая ваши добавления; modelSettings разрешается отдельно для каждой модели.

У семи ключей строгое значение снизу побеждает корпоративное. Обычно политика абсолютна — её не перебивает даже --settings. Но для этих ключей более строгий вариант из любого уровня выигрывает, потому что запретить себе лишнее вам никто мешать не станет: disableClaudeAiConnectors со значением true, enableArtifact со значением false (и disableArtifact: true), isolatePeerMachines со значением true, remoteControlAtStartup со значением false из проектного или локального файла, crossSessionInbound с более строгим значением на шкале «принимать — придержать — отказывать», useAutoModeDuringPlan и syncClaudeAiSkills со значением false.

Проектные разрешения ждут доверия к папке. permissions.allow и permissions.additionalDirectories из проектного файла начинают действовать только после того, как вы подтвердили доверие к этой папке. deny и ask действуют сразу — они только ограничивают.

А вот дальше самое важное, и это стоит прочитать всем, кто запускает claude -p в чужом репозитории. В неинтерактивном режиме диалог доверия не показывается, поэтому проектные разрешающие правила отбрасываются с предупреждением в поток ошибок — но хуки этого репозитория выполняются, его блок env применяется, его вспомогательные скрипты авторизации запускаются, поле allowed-tools его навыков действует, а серверы из его .mcp.json подключаются без вопросов. Отбрасываются именно разрешения, а не исполняемые части.

Безопасный запуск в непроверенной папке — это --setting-sources user, --bare, --restricted или --settings '{"disableAllHooks": true}'. Просто выставить disableAllHooks в своём пользовательском файле недостаточно: проектный файл старше и вернёт его обратно.

Переменные окружения — не уровень

Ещё одна вещь, которую обычно рисуют неправильно. Переменные окружения не стоят «между» уровнями настроек: кто кого перекрывает, решается для каждой пары «переменная — ключ» отдельно.

• ANTHROPIC_MODEL из оболочки перекрывает ключ model из любого файла.
• ANTHROPIC_DEFAULT_MODEL действует, только если model не задан нигде.
• --model и /model перекрывают ANTHROPIC_MODEL.
• А CLAUDE_CODE_EFFORT_LEVEL устроен наоборот и перекрывает --effort и /effort.

И отдельно: значение из блока env в настройках побеждает экспорт из оболочки, а не наоборот, как принято думать. Claude Code записывает каждую запись блока в окружение процесса поверх унаследованного значения. Удалить переменную из файла настроек нельзя — можно выставить её в пустую строку, что при выборе провайдера считается «не задана» (хотя дочерние процессы получат пустое значение). Переменные оболочки читаются один раз на старте, а значения из env перечитываются при изменении файла — кроме подсистем, которые настраиваются только при запуске, вроде телеметрии.

Скелет файла

Скаляры вроде model, theme, чисел и флагов пишутся на верхнем уровне. Сгруппированные настройки — permissions, env, hooks, statusLine, worktree, voice, sandbox, sshConfigs — вложенные объекты.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "opus",
  "outputStyle": "default",
  "theme": "dark",
  "autoCompactEnabled": true,
  "cleanupPeriodDays": 30,
  "includeCoAuthoredBy": false,
  "env": {
    "CLAUDE_CODE_USE_POWERSHELL_TOOL": "1",
    "DISABLE_TELEMETRY": "1"
  },
  "permissions": {
    "allow": ["Bash(npm run build)", "Edit(src/**)"],
    "ask": ["Bash(git push:*)"],
    "deny": ["Read(./.env)"],
    "defaultMode": "acceptEdits",
    "additionalDirectories": ["../shared-lib"]
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "npm run lint" }]
      }
    ]
  },
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 1
  },
  "worktree": {
    "symlinkDirectories": ["node_modules"],
    "baseRef": "fresh"
  },
  "enabledPlugins": {
    "formatter@anthropic-tools": true
  }
}

Аутентификация и провайдеры

Значение gateway у forceLoginMethod учитывается только из источника, лежащего на самой машине: файла политики, домена настроек macOS или ветки HKLM. В пользовательском, проектном, локальном и в HKCU оно считается незаданным — иначе корпоративный вход можно было бы перенаправить из репозитория.

Модель, мышление, усилия

Три значения по умолчанию, которые меняют поведение и о которых редко пишут.

switchModelsOnFlag включён. То есть при срабатывании фильтра безопасности модель молча меняется, чтобы не прерывать диалог. Если выключить, интерактивная сессия встанет и спросит вас, а неинтерактивный запуск завершит запрос ошибкой — для скриптов это часто правильнее, потому что тихая подмена модели в CI выглядит как необъяснимая смена поведения.

promptCacheTtl подбирается сам: час на подписке, пять минут иначе. Переменная окружения его перекрывает.

effortLevel не принимает max намеренно, чтобы максимальный уровень не оставался включённым навсегда; на сессию он ставится командой или флагом.

Права доступа инструментов

Самая практически важная часть файла — и самая недооценённая по количеству подводных камней. Вложенный объект permissions:

Рядом ключи верхнего уровня: skipDangerousModePermissionPrompt и skipAutoPermissionPrompt помнят, что вы уже приняли соответствующее предупреждение; allowManagedPermissionRulesOnly [админ] велит учитывать списки только из политики; disableAutoMode выключает авто-режим; useAutoModeDuringPlan разрешает применять его в режиме планирования, по умолчанию да.

Режимы

dontAsk — не «не спрашивать по мелочам». Это самое опасное недопонимание во всей теме прав, и я сам его повторял. Режим не смягчает, а ужесточает: всё, что в обычном режиме вызвало бы вопрос, автоматически запрещается. Работает только то, что попало в allow, встроенный набор безопасных команд чтения и то, что одобрил хук. Ваши собственные правила ask в этом режиме не спрашивают, а отказывают; вопрос агента к вам тоже отклоняется, даже если разрешён.

Ещё одна тонкость: значение auto не действует из проектных и локальных настроек — его надо задавать в пользовательском файле. А сессии, запущенные из расширения VS Code, читают только пользовательский, корпоративный и --settings.

Формат правила

Правило записывается как Инструмент(уточнение): Bash(npm run build), Edit(src/**), Read(~/.zshrc).

{
  "permissions": {
    "allow": ["Bash(npm run:*)", "Edit(src/**)", "Read(~/.config/**)"],
    "ask": ["Bash(git push:*)"],
    "deny": ["Read(./secrets/**)", "Read(./.env)"],
    "defaultMode": "acceptEdits",
    "additionalDirectories": ["../shared", "/tmp/workspace"]
  }
}

Выглядит просто. Дальше — двенадцать правил поведения, каждое из которых объясняет какой-нибудь популярный вопрос «почему моё правило не работает».

Порядок проверки: сначала запрет, потом вопрос, потом разрешение

Правила проверяются в фиксированном порядке — deny, затем ask, затем allow, — и побеждает первое совпадение, а не самое точное. Отсюда два следствия, которые ломают ожидания.

Широкий запрет перекрывает узкое разрешение: deny с Bash(aws *) заблокирует allow с Bash(aws s3 ls). Исключений из запрета не бывает — механизма «запретить всё, кроме» здесь нет.

Совпавшее ask спрашивает, даже если есть более точное allow. Это не ошибка, это способ сказать «эту команду всегда подтверждаю руками», и она работает поверх любых разрешений.

Между уровнями настроек то же самое: запрет из пользовательского файла бьёт разрешение из проектного и наоборот, потому что все deny со всех уровней проверяются раньше любых allow.

Ещё одна мелочь с большими последствиями: голое имя инструмента в deny убирает инструмент из контекста целиком. Запись "Bash" в запретах означает, что агент про этот инструмент вообще не узнает. А Bash(rm *) оставляет инструмент видимым и запрещает только совпадающие вызовы.

Защищённые пути проверяются раньше ваших правил

Существует список путей, запись в которые проверяется до того, как посмотрят на allow. Поэтому Edit(.claude/**) в любом файле настроек не даёт ровным счётом ничего — и это самый частый источник вопросов «почему моё разрешение игнорируется».

В списке защищённых каталогов: .git, .config/git, .vscode, .idea, .husky, .cargo, .devcontainer, .yarn, .mvn и .claude целиком, кроме .claude/worktrees. Из файлов — .gitconfig, .gitmodules, все файлы профилей и запуска оболочки, .envrc, .npmrc, .yarnrc*, .pnp.cjs, bunfig.toml, .bazelrc, .pre-commit-config.yaml, lefthook.*, gradle-wrapper.properties, .ripgreprc, pyrightconfig.json, .mcp.json и .claude.json.

Логика понятна: всё это — файлы, правка которых меняет поведение вашей же машины при следующей команде, вплоть до того, что выполнится вместо git commit. Что произойдёт при попытке, зависит от режима: обычный и acceptEdits спросят, plan разрешит только если доступен обход, auto отдаст классификатору, dontAsk откажет, bypassPermissions разрешит. В диалоге при этом есть отдельный пункт — разрешить правку своих настроек на эту сессию.

Предохранитель на удаление

rm и rmdir, нацеленные на критические пути, не одобряются ничем: ни правилом в allow, ни хуком, вернувшим разрешение.

Критические пути — это корень файловой системы и любой его непосредственный потомок, домашняя папка, корни дисков на Windows и их каталоги первого уровня, текущая рабочая папка и её родители, а также шаблоны внутри добавленных директорий.

Самое интересное — таблица по режимам, потому что она устроена не так, как все ожидают:

То есть режим «обходить все подтверждения» здесь строже, чем авто-режим: --dangerously-skip-permissions на таком удалении всё равно остановится.

Считается и то, что выглядит безобидно: rm -rf "$DIR"/* попадает под предохранитель, потому что пустая переменная превращает это в удаление от корня. Спрятать команду в подстановку, обратные кавычки или подстановку процесса не поможет — проверка их видит.

Четыре якоря пути

Правила Read и Edit используют синтаксис .gitignore, и в нём четыре разных способа привязать путь. Их путают постоянно.

Третья строка — ловушка. Одиночный слэш в начале не означает абсолютный путь: он привязывает правило к тому файлу настроек, где оно написано. Правило Read(/secrets/**) в ~/.claude/settings.json означает ~/.claude/secrets/**, а вовсе не secrets в вашем проекте. В проектных настройках тот же слэш отсчитывается от основной рабочей папки, в --settings — от папки указанного файла, а правила из локальных настроек с версии 2.1.211 привязаны к рабочей папке сессии, а не к корню репозитория, — то есть в отдельной рабочей копии Edit(/src/**) попадёт в её собственный src.

Голое имя файла ведёт себя как в .gitignore и совпадает на любой глубине: Read(.env) — это то же самое, что Read(**/.env). А вот Read(//**/.env) привязано к корню файловой системы.

На Windows пути приводятся к POSIX-виду до сравнения: C:\Users\alice превращается в /c/Users/alice. Поэтому правило на все диски пишется как //**/.env, а на конкретный — //c/**/.env.

Одно и то же правило ловит разную глубину в allow и в deny

Односегментный относительный шаблон папки ведёт себя асимметрично, и это специально.

Edit(src/**) в allow совпадает только с папкой src в корне рабочей директории. Он же в deny или ask совпадает с папкой src на любой глубине — то есть поймает и vendor/pkg/src/lib.js.

Смысл понятный: разрешение должно быть узким, запрет — широким. Все остальные формы ведут себя одинаково в любом типе правил: Edit(/src/**) и Edit(src/components/**) совпадают только там, где написаны, Edit(**/src/**) — везде. Поведение поменялось в 2.1.214: до неё Edit(src/**) ловил любую глубину и в разрешениях тоже.

Двоеточие только в конце, а пробел перед звёздочкой значим

Форма Bash(ls:*) — это ровно то же самое, что Bash(ls *). Но распознаётся она только в конце шаблона: в Bash(git:* push) двоеточие — обычный символ, и правило не совпадёт ни с чем.

Пробел перед звёздочкой — часть правила. Bash(ls *) требует пробела и потому не совпадает с lsof; Bash(ls*) — совпадает. Завершающая звёздочка ловит и голую команду без аргументов, но только если она в правиле единственная: Bash(ls *) совпадёт с ls, а Bash(* --help *) совпадёт с npm --help x и не совпадёт с npm --help.

Всё, что стоит до первой звёздочки, сравнивается буквально. Отсюда неприятность: Bash(git * main) разрешает любую подкоманду git, включая -c с произвольной конфигурацией. С версии 2.1.246 на разрешающие правила со звёздочкой перед подкомандой печатается предупреждение при запуске.

Составные команды

Разделители, которые Claude Code понимает: &&, ||, ;, |, |&, & и перевод строки. Каждая часть должна совпасть с правилом отдельно — общего разрешения на всю строку не бывает.

Отдельный случай: если оператор оказался в конце и после него ничего нет — например npm test &&, — команда считается неразбираемой и не делится вовсе. Тогда даже Bash(npm *) её не одобрит.

Когда вы отвечаете «да, и больше не спрашивай» на составную команду, сохраняется отдельное правило на каждую часть, которой это требовалось. Переход в подпапку породит своё правило на чтение. Больше пяти правил из одной команды не сохранится.

Перенаправления вывода >, >>, 2> проверяются как запись в файл — против ваших правил Edit, списка защищённых путей и рабочих директорий. /dev/null из проверки исключён; цель, начинающаяся с ~ или содержащая шаблон, требует подтверждения всегда.

Какие обёртки снимаются, а какие нет

Перед сопоставлением с правилами из команды убираются: timeout, time, nice, nohup, stdbuf, встроенные command и builtin, noglob из zsh и голый xargs — последний только без флагов, xargs -n1 grep разбирается как команда xargs.

Снимается и ведущее присваивание известной безопасной переменной, поэтому Bash(npm test *) совпадёт с NODE_ENV=test npm test. Разрешающее правило дальше присваивания любой другой переменной не пройдёт, а запрещающее пройдёт через любое.

Список фиксирован и не настраивается. И в нём нет ни одного запускателя окружения: npx, docker exec, direnv exec, devbox run, mise exec не снимаются. Практический вывод: Bash(devbox run *) — это разрешение на devbox run rm -rf ., потому что для проверки это команда devbox, а не rm.

Отдельно есть команды, которые нельзя одобрить префиксным правилом никогда: watch, setsid, ionice, flock, а также find с -exec или -delete. В обычном режиме они спросят всегда.

Правила для Write, Glob, NotebookEdit и MultiEdit принимаются и не работают

Файловые права проверяются только против правил Edit(...) и Read(...). Правило вида Write(docs/**) или Glob(docs/**) будет разобрано, сохранено, показано в /permissions — и никогда не использовано. С версии 2.1.210 на такое печатается предупреждение при запуске.

Пишите Edit(...) вместо Write, NotebookEdit и MultiEdit и Read(...) вместо Glob. Голое имя инструмента без пути при этом работает: запретить Write целиком можно.

Полезное следствие: запрещающее правило Read на путь заодно блокирует правку и запись по нему — но не NotebookEdit.

Символические ссылки

Каждое обращение к файлу проверяется по двум путям сразу: по самой ссылке и по тому, куда она ведёт. Правила при этом асимметричны.

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

Запрет действует, если совпал хотя бы один. Поэтому ссылка на запрещённый файл запрещена сама.

На практике: если разрешено Read(./project/**) и запрещено Read(~/.ssh/**), то ./project/key, ведущий на ~/.ssh/id_rsa, будет заблокирован.

Правила по параметрам инструмента

Малоизвестное семейство. Запрещающие и спрашивающие правила умеют совпадать по скалярному полю входных данных инструмента:

{
  "permissions": {
    "deny": ["Agent(model:opus)", "Agent(isolation:worktree)", "Bash(run_in_background:true)"]
  }
}

Один параметр на правило, вложенные поля не поддерживаются, * подставляется вместо значения. Параметр, который модель не передала, не совпадает никогда — то есть Agent(model:opus) не поймает вызов, где модель не указана вовсе. Значение сравнивается с тем, что пришло, до нормализации: алиас opus совпадёт, а полный идентификатор той же модели — нет.

Главное поле инструмента таким образом не матчится намеренно: command, file_path, path, notebook_path, url исключены. Правило Bash(command:rm *) игнорируется с предупреждением — его было бы слишком легко обойти составной командой.

Для MCP-инструментов параметрические правила работают только через флаг --disallowedTools: любое правило с mcp__ и скобками в файле настроек пропускается и попадает в список некорректных настроек и в вывод claude doctor.

Шаблоны в имени инструмента

В запрещающих и спрашивающих правилах имя инструмента можно задавать шаблоном, и он должен покрывать имя целиком: "*" — все инструменты, "mcp__*" — все инструменты MCP.

В разрешающих правилах шаблон допустим только после буквального префикса mcp__<сервер>__, причём имя сервера должно быть без шаблонов. То есть mcp__github__get_* работает, а "*", "B*" и "mcp__*" в allow пропускаются с предупреждением и не разрешают ничего.

И ещё одна ловушка: имя инструмента на экране может отличаться от канонического. То, что показано как «Stop Task», канонически называется TaskStop, и в правилах и в фильтрах хуков работает только каноническое имя.

WebFetch — два разных правила с похожим видом

Голое WebFetch и WebFetch(domain:*) — не одно и то же, потому что вторая форма заодно правит список доменов песочницы.

Шаблоны в домене: *.example.com ловит поддомены любой глубины, но не сам example.com. В любой другой позиции звёздочка совпадает только с текстом между двумя точками — example.* поймает example.org и не поймает example.evil.com.

И трезвое замечание: пока у агента есть доступ к оболочке, разрешения WebFetch не ограничивают сетевой доступ вообще никак.

Встроенный набор безопасных команд

Часть команд выполняется без вопроса в любом режиме, и этот список зашит: ls, cat, echo, pwd, head, tail, grep, find, wc, which, diff, stat, du, cd и read-only формы git. Расширить его нельзя, можно только перекрыть своим правилом ask или deny.

Но и он спросит, если: незакавыченный шаблон встретился в команде, у которой есть флаги записи или запуска (find, sort, sed, git — шаблон мог бы развернуться в -delete); у docker есть -H, --context, --url или --connection; у file есть -m, --magic-file, -f или --files-from; в аргументах сетевой путь Windows; команда длиннее десяти тысяч символов или не разбирается. Плюс cd вместе с git спросит, если папка действительно меняется — в новой папке могут быть свои хуки git.

PowerShell

Правила для PowerShell устроены так же, сравниваются без учёта регистра и приводят популярные псевдонимы к канону: PowerShell(Get-ChildItem *) совпадёт и с gci, и с ls, и с dir. Команда разбирается по синтаксическому дереву и делится по |, ;, а на седьмой версии ещё по && и ||; каждая часть проверяется отдельно.

У Remove-Item своя проверка, более жёсткая, чем у rm: системные пути и цели с шаблоном — голая *, всё, что кончается на /* или \*, включая $dir/*, — запрещаются во всех режимах без вопроса, ещё до классификатора. По обычным правилам режима идёт только случай «рабочая папка или её родитель с рекурсией», и вот он обходом подтверждений снимается.

И отдельно про Windows: любая команда, в аргументах которой есть сетевой путь вида \\сервер\ресурс\файл, спросит подтверждение, даже если во всём остальном она безобидна, — такой путь может утащить учётные данные Windows.

Авто-режим

С 14 августа 2026 это режим по умолчанию для новых сессий на Pro, Max и Team. Решение о каждом действии принимает классификатор, а не список правил, и настраивается он отдельным объектом autoMode.

Три вещи, которые тут важнее самой таблицы.

Строка "$defaults" обязательна почти всегда. В любом из четырёх списков она подмешивает штатный набор правил. Если её не написать, весь встроенный список этой секции молча исчезает — вместе с мягкими блоками на форс-пуш, на curl | bash, на деплой в продакшен и на обход самого авто-режима, и с жёстким блоком на утечку данных. Ваши правила должны дополнять набор, а не заменять его.

Узкие разрешения обходят классификатор. Правило вроде Bash(npm test) в авто-режиме продолжает действовать и разбирается до классификатора. Приостанавливаются только широкие разрешения на произвольное выполнение — Bash(*), интерпретаторы со звёздочкой — и все правила, называющие инструмент наблюдения. То есть узкое правило может пропустить разрушительный аргумент, которого никто не посмотрел. Закрывается это classifyAllShell: true, и тогда на время авто-режима отключаются все разрешающие правила оболочки.

Классификатор не читает настройки проекта. Он берёт autoMode только из пользовательского файла, корпоративного и --settings. Иначе репозиторий мог бы подсунуть себе разрешения; локальные настройки читались до версии 2.1.207, теперь нет.

Посмотреть и разобрать конфигурацию можно из терминала:

claude auto-mode config                       # что действует и откуда взялось
claude auto-mode defaults                     # штатные правила всех четырёх списков
claude auto-mode defaults --label 'Git Destructive'   # полный текст одного правила
claude auto-mode critique                     # разбор ваших правил моделью
claude auto-mode reset --yes                  # сбросить к штатным без вопроса

Подкоманда critique — недооценённая: она просит модель разобрать ваши собственные правила и показать те, что двусмысленны, избыточны или будут давать ложные срабатывания.

Выключается режим ключом disableAutoMode, и здесь есть ловушка: значение должно быть строкой "disable". Массив или true схема пропустит без ошибки, но код сравнивает именно со строкой, и режим тихо останется включённым. Скрыть мастер настройки можно записью "auto-mode-setup": "off" в skillOverrides; disableBundledSkills его не выключает, потому что это встроенная команда, а не навык.

MCP-серверы

Последняя строка исправляет распространённое утверждение, которое я и сам раньше повторял: «серверы задаются только в .mcp.json, а в настройках — лишь права на них». Это верно для вас, но не для администратора: managedMcpServers в корпоративных настройках содержит именно конфигурации серверов и раскатывается на всех через файл политики или систему управления устройствами.

Обычные же серверы задаются в .mcp.json или через claude mcp add.

Хуки

Хуки — тема на отдельную статью, и она у меня есть: там разобраны все события, форматы обмена и рабочие примеры. Здесь ключи настроек и то, что чаще всего ломается.

hooks — объект вида «событие → массив матчеров». У матчера есть фильтр matcher и список обработчиков.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "npm run lint" },
          { "type": "command", "command": "echo", "args": ["done"] }
        ]
      }
    ]
  }
}

Событий тридцать три. По инструментам: PreToolUse, PostToolUse, PostToolUseFailure, PostToolBatch. По разговору: UserPromptSubmit, UserPromptExpansion, Stop, StopFailure, Notification, MessageDisplay. По сессии: SessionStart, SessionEnd, Setup, InstructionsLoaded, ConfigChange. По сжатию и смене модели: PreCompact, PostCompact, PreModelSwitch, PostModelSwitch. По правам: PermissionRequest, PermissionDenied. По субагентам и задачам: SubagentStart, SubagentStop, TeammateIdle, TaskCreated, TaskCompleted. По файлам и папкам: FileChanged, CwdChanged, DirectoryAdded, WorktreeCreate, WorktreeRemove. И две на формы MCP: Elicitation, ElicitationResult.

Обработчик бывает пяти видов, вид задаётся полем type: command запускает программу или строку оболочки, prompt спрашивает маленькую быструю модель, agent отправляет полноценного агента, http дёргает адрес, mcp_tool вызывает инструмент MCP-сервера. Общие необязательные поля — if с условием, timeout, statusMessage для спиннера, once для однократного выполнения за сессию и async с родственным asyncRewake.

Три вещи, из-за которых хук «работает, но ничего не делает»

Код выхода 1 ничего не блокирует. Блокирует только код 2, и только примерно на трети событий. Единица и любой другой ненулевой код на большинстве событий — это просто неблокирующая ошибка в журнале. Код 2 при этом сильнее вашего же JSON: даже если вы вернули решение «разрешить», двойка запретит.

Где двойка блокирует: PreToolUse, UserPromptSubmit (стирая промпт), UserPromptExpansion, Stop, SubagentStop, TeammateIdle, TaskCreated, TaskCompleted, ConfigChange, PostToolBatch, PreModelSwitch. Где игнорируется: PermissionRequest и PermissionDenied — там решают поля JSON, — и StopFailure. На PostToolUse двойка не блокирует, а показывается модели. На WorktreeCreate прерывает любой ненулевой код. И отдельная асимметрия: истёкший таймаут на PreToolUse не блокирует, а на PreModelSwitch — блокирует.

Вывод хука модель почти никогда не видит. Обычный текст в стандартный вывод при коде 0 попадает в отладочный журнал, а не в разговор. Модели он показывается ровно на четырёх событиях: UserPromptSubmit, UserPromptExpansion, SessionStart и PostModelSwitch. Поток ошибок не показывается нигде и никогда. На остальных событиях передать что-то модели можно только структурированным ответом — полем дополнительного контекста или системным сообщением. JSON при этом разбирается, только если вывод начинается с { и заканчивается }.

Фильтр иногда игнорируется целиком, а иногда это регулярное выражение. "*", пустая строка или отсутствие поля означают «все». Фильтр, состоящий только из букв, цифр, _, -, пробелов, запятых и |, — это точное совпадение или перечисление. Любой другой символ превращает его в регулярное выражение, которое проверяется без привязки к началу и концу, если вы не написали их сами. Регистр учитывается.

И фильтр не всегда про имя инструмента. На SessionStart он сравнивается со способом старта, на SessionEnd — с причиной завершения, на сжатии — с manual или auto, на ConfigChange — с тем, какой файл настроек изменился, на FileChanged — с именем файла, на смене модели — с каноническим именем модели. А события UserPromptSubmit, PostToolBatch, Stop, CwdChanged, TeammateIdle, задачи, рабочие копии и MessageDisplay фильтра не принимают вовсе и молча игнорируют написанный.

Таймауты по умолчанию неодинаковые: у command, http и mcp_tool — десять минут, но на UserPromptSubmit и на событиях смены модели тридцать секунд, а на MessageDisplay десять; у prompt — тридцать секунд, у agent — минута; всем хукам SessionEnd вместе отводится полторы секунды. Асинхронные не ограничены вовсе.

На Windows стоит помнить про форму с отдельным списком аргументов: она выполняется без оболочки, и ей нужен настоящий исполняемый файл — обёртки .cmd и .bat требуют либо строковой формы, либо запуска через интерпретатор.

Git: коммиты, pull request, атрибуция

{
  "attribution": { "commit": "", "pr": "" },
  "includeGitInstructions": true
}

Интерфейс и терминал

Значения theme: auto (по фону терминала), dark, light, light-daltonized, dark-daltonized, light-ansi, dark-ansi, а также custom:<имя> для темы из ~/.claude/themes/ и custom:<плагин>:<имя> для темы из плагина.

Часть ключей читается только из пользовательского файла, --settings и политики: spinnerTipsOverride с файлом подсказок, footerLinksRegexes и spellcheck. Проектный файл их переопределить не может — иначе репозиторий смог бы дорисовать вам в интерфейс произвольную ссылку.

Настройки, живущие в ~/.claude.json

Эти ключи в settings.json игнорируются молча. Обычно их пишет сам Claude Code или /config, но знать про них полезно.

Первый ключ стоит того, чтобы про него узнать: сочетание Ctrl+E на вопросе о запуске команды даёт человеческий разбор того, что эта команда делает, — без её выполнения. На незнакомой команде из чужого репозитория это ровно та кнопка, которой не хватает.

Строка состояния

Поля statusLine: type со значением "command", command со скриптом, padding, refreshInterval — пересчитывать раз в столько секунд, — и hideVimModeIndicator, если скрипт рисует режим vim сам.

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 1,
    "refreshInterval": 5
  }
}

Скрипту приходит на вход JSON с контекстом сессии: модель, папка, стоимость, заполненность контекста. Печатает он одну строку. Это, пожалуй, самая недооценённая настройка: постоянно видимые цифры расхода меняют поведение сильнее, чем любые инструкции об экономии. Учтите только, что disableAllHooks выключает и её.

Контекст, память, сессии

Про autoContinueAtUsageLimit стоит знать две вещи: он включён по умолчанию и читается только из пользовательского файла, --settings и политики — то есть проектный или локальный файл, который его задаёт, не игнорируется, а выключает возможность.

Навыки

skillOverrides стоит знать всем, у кого много навыков: их описания висят в контексте постоянно, и name-only для редко нужных освобождает заметный кусок. Тот же ключ — способ запретить агенту самому запускать конкретную команду, оставив её вам: значение user-invocable-only.

Плагины и маркетплейсы

Воркфлоу, агенты, тиммейты

Значение auto у teammateMode определено точно: разделённые панели, если сессия идёт внутри tmux, или внутри iTerm2 с доступной утилитой командной строки, или если tmux установлен; иначе всё выполняется внутри процесса. Значение iterm2 — родные разделённые панели iTerm2, появилось в 2.1.186.

Ключ teammateDefaultModel в схеме ещё есть, но из продукта убран в 2.1.234 и ни на что не влияет.

Worktree

Вложенный объект worktree управляет тем, как заводятся отдельные рабочие копии под сессии и фоновых агентов.

{
  "worktree": {
    "symlinkDirectories": ["node_modules", ".cache"],
    "sparsePaths": ["packages/app", "packages/shared"],
    "baseRef": "fresh",
    "bgIsolation": "worktree"
  }
}

Удалённое управление, SSH, окружения

Три из этих ключей принимают только настоящее булево true: строка "true" или единица будут проигнорированы с предупреждением в журнале. Это disableDesktopLocalSessions, disableBrowserExternalNavigation и disableMobileSimulatorTools. Терминальный CLI их не читает вовсе — они про desktop-приложение.

Про requireCoworkFullVmSandbox есть важный побочный эффект: внутри полной виртуальной машины нет ни политики устройства, ни файла корпоративных настроек — доставлять их туда придётся иначе.

{
  "remote": { "defaultEnvironmentId": "env-123" },
  "sshConfigs": [
    {
      "id": "prod-box",
      "name": "Prod",
      "sshHost": "deploy@prod.example.com",
      "sshPort": 22,
      "startDirectory": "~/app"
    }
  ]
}

Уведомления, голос, перерывы

{
  "voice": { "enabled": true, "mode": "hold", "autoSubmit": true },
  "breakReminder": { "enabled": true, "intervalMinutes": 120 },
  "quietHours": { "enabled": true, "start": "22:00", "end": "07:00" }
}

Песочница и сеть

Объект sandbox управляет тем, что разрешено процессам внутри изоляции. Самый длинный раздел схемы и самый редко используемый — но если вы пускаете агента в режиме, где он не спрашивает разрешений, читать надо именно его.

Сразу исправлю распространённую ошибку в структуре: пути на чтение и запись лежат не прямо в sandbox, а в sandbox.filesystem. Правило "sandbox": {"denyRead": [...]} не сработает.

Три вещи стоит выделить.

allowUnsandboxedCommands по умолчанию включён. То есть заблокированную песочницей команду агент может повторить снаружи через специальный параметр. Если вы включали песочницу ради изоляции, это, скорее всего, не то, чего вы хотели, — выключается явным false.

enabledPlatforms делает конфигурацию инертной целиком. На системе не из списка не будет ни песочницы, ни автоматических разрешений, ни предупреждения при старте, ни падения по failIfUnavailable. Тихо, как будто раздела и нет.

Маскировка секретов работает не везде. На macOS и Windows режим mask вырождается в deny: подменить значение на лету там нечем. У записей маскировки есть ещё поле onExtractNoMatch — что делать, если регулярное выражение ничего не нашло: warn (по умолчанию) пропустит переменную немаскированной, deny уберёт её внутри песочницы, error остановит запуск.

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "allowUnsandboxedCommands": false,
    "network": {
      "allowedDomains": ["api.example.com", "*.githubusercontent.com"],
      "deniedDomains": ["telemetry.example.com"]
    },
    "filesystem": {
      "denyRead": ["~/.ssh", "~/.aws"],
      "denyWrite": ["~/.config"]
    }
  }
}

Обновления и всё остальное

Схема принимает ещё несколько служебных ключей: modelProposedGoals, totalTokensReminder с родственниками и disableDeepLinkRegistration. Они внутренние, в интерфейсе не появляются и нигде не описаны.

Переменные окружения

Блок env в настройках — это объект «имя → значение». Все значения строки: числа и флаги пишутся в кавычках, "PORT": "3000", флаг — "1".

Честная оговорка о полноте: официальная документация перечисляет по именам триста сорок девять переменных, включая по регионам на каждую модель у каждого провайдера и весь набор телеметрии. Пересказывать их здесь бессмысленно. Ниже — те, что реально используются, плюс поведение блока env, которое нигде не собрано в одном месте.

{
  "env": {
    "CLAUDE_CODE_USE_POWERSHELL_TOOL": "1",
    "ANTHROPIC_MODEL": "claude-opus-5",
    "BASH_DEFAULT_TIMEOUT_MS": "120000",
    "DISABLE_TELEMETRY": "1"
  }
}

Как ведёт себя блок env

Он побеждает экспорт из оболочки. Значение из файла настроек записывается в окружение процесса поверх унаследованного. Это ровно обратно тому, что обычно ожидают.

Удалить переменную нельзя — можно выставить пустую строку. При выборе провайдера пустое значение считается незаданным, но дочерние процессы получат именно пустую строку.

Значения перечитываются на ходу, когда меняется файл, — кроме подсистем, настраиваемых только при запуске, вроде телеметрии. А /cd с версии 2.1.246 накладывает env новой папки поверх старой.

Проектным и локальным настройкам разрешено не всё. Отбрасываются три группы: переменные, задающие расположение файлов (CLAUDE_CONFIG_DIR, CLAUDE_CODE_TMPDIR, HOME, TMPDIR, TMP, TEMP, XDG_*); переменные, включающие выгрузку содержимого сессии (OTEL_LOG_RAW_API_BODIES, ENABLE_BETA_TRACING_DETAILED, BETA_TRACING_ENDPOINT); и переменные, влияющие на запуск и синхронизацию (CLAUDE_CODE_PROCESS_WRAPPER, CLAUDE_CODE_SYNC_SKILLS, CLAUDE_CODE_SYNC_PLUGINS, кэш и seed-папка плагинов). Список расширился как раз в 2.1.251. Предупреждение об этом видно только под отладкой.

Ещё несколько переменных игнорируются в любом файле и читаются только из окружения запуска: CLAUDE_CODE_REMOTE, CLAUDE_CODE_ACCOUNT_UUID, сокет и токен межсессионного обмена, CLAUDE_CODE_PROJECT_DIR_NAME и CLAUDE_CODE_RESTRICTED.

И обратное направление, о котором почти не пишут: Claude Code сам выставляет переменные дочерним процессам. Их видно из хуков и из любого запущенного скрипта: CLAUDECODE=1, CLAUDE_CODE_CHILD_SESSION=1, CLAUDE_CODE_SESSION_ID, CLAUDE_PID — собственный идентификатор процесса, CLAUDE_EFFORT с текущим уровнем усилий (режим ultracode показывается как xhigh), а в облачных сессиях CLAUDE_CODE_REMOTE=true и идентификатор удалённой сессии. Хук, которому нужно знать уровень усилий или отличить дочернюю сессию от основной, берёт это отсюда, а не гадает.

Провайдеры и аутентификация

Провайдеров, кстати, не два и не три: кроме Anthropic API, Amazon Bedrock и Google Cloud поддерживаются Microsoft Foundry и Claude Platform на AWS, и у каждого свой набор переменных и своё соответствие алиасов моделям.

Модели, контекст, лимиты

Поведение и среда

Три засады в этой таблице стоит проговорить.

Таймауты MCP различаются на пять порядков. Старт сервера — тридцать секунд. А вызов инструмента по умолчанию — около двадцати восьми часов, то есть фактически без ограничения. Плюс у серверов по HTTP и у облачных коннекторов каждый запрос дополнительно ограничен минутой, и это отдельный лимит.

CLAUDE_CODE_PROJECT_DIR_NAME в одиночку не работает — только вместе с CLAUDE_CONFIG_DIR, и только из окружения, а не из файла настроек.

Безопасный режим отбирает больше, чем кажется. CLAUDE_CODE_SAFE_MODE — это не только инструкции и навыки: не грузятся плагины, хуки, MCP-серверы, свои команды и агенты, стили вывода, воркфлоу, темы, горячие клавиши, строка состояния, источник подсказок файлов, языковые серверы и автопамять. Остаётся только корпоративная политика, включая заданные ею хуки и строку состояния. Это отладочный режим «выключить всё, что я настроил», и для поиска сломанной конфигурации он идеален.

Рендеринг и доступность

Одной строкой, потому что переменных много, а нужны они редко. Классический рендерер возвращает CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN, и он сильнее и CLAUDE_CODE_NO_FLICKER, и настройки tui. Есть отдельные выключатели мыши и кликов, скорости прокрутки, виртуальной прокрутки, полной перерисовки, родного курсора, подсветки синтаксиса, гиперссылок и truecolor в tmux. Для доступности — CLAUDE_AX_SCREEN_READER и родственные ей.

Приватность, телеметрия, обновления