Как получить максимум пользы от сессий Claude Code

Полный перевод статьи из блога Claude на русский. Оригинал — по ссылке.

Кратко

• Выполняйте \/clear между задачами. Это предотвращает отправку модели предыдущего нерелевантного контекста, что может снизить использование токенов.
• Задайте модель и уровень усилий перед началом. Изменение любого из них в середине разговора может нарушить кэш подсказки, что может увеличить стоимость токенов.
• Упоминайте файлы через @ вместо того, чтобы называть их. Файл прикрепляется непосредственно к Вашему сообщению, что экономит вызов Read или поиск, если Claude должен найти его.
• Добавляйте флаги подавления вывода к шумным командам или запускайте их в субагенте. Вывод команды добавляется в разговор так же, как файл, и остается там до конца сеанса.
• Выполните \/context один раз в новом сеансе. Он показывает, что загружено (CLAUDE.md, определения инструментов MCP), поэтому Вы можете убрать все ненужное.
• \/compact перед тем, как сделать перерыв в работе за клавиатурой. Кэш подсказки истекает через час, а суммаризация разговора обходится намного дешевле, пока он еще кэширован.

Максимизация ценности

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

С агентными инструментами для программирования, такими как Claude Code, она есть. Одна и та же выполненная задача также может стоить по-разному в зависимости от того, как Вы используете инструмент. 

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

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

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

Итак, давайте посмотрим, от чего зависит цена токена, затем — от чего зависит, сколько токенов отправляет сеанс, и попутно — что это означает для того, как Вы ведете сеанс.

Что определяет цену токена

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

Три фактора определяют, сколько времени занимает обработка токена: какую модель Вы запускаете, является ли это входным токеном (который поступает на вход) или выходным токеном (который выходит), и был ли он кэширован.

Модель

Более крупная модель выполняет больше работы как с входными, так и с выходными токенами. Какая модель подходит для какого вида работы — отдельная тема, и мы рассмотрели её в Выбор модели Claude и уровня усилия в Claude Code.

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

Входные и выходные токены

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

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

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

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

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

Совет: если Вы уже знаете, что сеанс будет рутинной работой, MAX_THINKING_TOKENS=0 отключает размышления claude для этого одного сеанса (кроме Fable 5), что является ступенью ниже, чем низкий уровень \/effort.

Кэширование промптов

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

Чтение из кэша стоит 0,1x цены ввода, потому что сервер загружает состояние вместо того, чтобы вычислять его. Запись токенов в кэш стоит немного дороже обычного ввода, до 2x, поскольку серверу также приходится затем удерживать состояние. Но запись происходит один раз на токен, а чтения за 0,1x происходят на каждом ходе после неё.

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

Допустим, мы набираем «исправь падающий тест в utils.test.ts». Вот что Claude Code отправляет для этого:

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

1. Модель не может исправить тест, которого она не видела, поэтому она немного размышляет и отвечает вызовом Read для utils.test.ts (выходные токены). Claude Code читает файл, добавляет его к разговору и снова отправляет всё целиком (входные токены). На этот раз всё из запроса 1 считывается обратно из кэша за одну десятую цены, и единственное, что предварительно заполняется по полной цене, — это новое: вызов Read и файл.

1. Теперь модели нужен файл, который тестируется (вывод). Ещё один Read, ещё одно добавление, и всё снова отправляется: запросы 1 и 2 из кэша, второй файл — по полной цене (входные токены).

1. Модель отвечает с помощью Edit (вывод). Claude Code применяет его, добавляет результат и снова отправляет всё. Та же история: Edit и его результат — новые, всё перед ними — чтение из кэша (входные данные).

1. Модель запускает npm test (вывод). Claude Code добавляет вывод тестов и снова отправляет всё, при этом вывод тестов — единственная новая часть (ввод).

1. Тесты проходят, и модель отвечает кратким резюме (вывод). Нет вызова инструмента — значит, нечего добавлять и не будет запроса 6, так что мы закончили.

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

Это весь счёт за один ход: чтение кэша по истории, полная цена ввода за всё новое и цена вывода за ответ.

Это применимо и к подписке. Вы не видите эти цены напрямую, но именно эти запросы расходуют Ваши лимиты.

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

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

• /model: у каждой модели свой кэш, поэтому на следующем ходу весь разговор снова предзаполняется по полной цене. (Сюда входит opusplan, который переключает модели каждый раз, когда Вы входите в режим планирования или выходите из него.)
• /effort: уровень усилий тоже является частью того, по чему определяется ключ кэша, так что ситуация такая же. Поэтому и /model , и /effort просят Вас подтвердить переключение в середине разговора.
• Быстрый режим: также часть ключа, и повторное предзаполнение происходит по ценам быстрого режима, поэтому, если Вы собираетесь включить его, включайте его в начале. (Снова выключить его бесплатно с точки зрения кэша.)
• \/compact: разговор заменяется более коротким, поэтому в нём больше ничего не совпадает (системный промпт перед ним сохраняется). Написание самой сводки обходится недорого, пока старый разговор всё ещё находится в кэше, поэтому это намного дешевле перед долгим перерывом, чем после него.
• Время: каждый ход сбрасывает таймер, но кэш истекает через час при подписке или через пять минут при ключе API (ENABLE_PROMPT_CACHING_1H=1 делает это часом). Вернитесь позже этого срока — и следующий ход снова предварительно заполнит весь разговор. Возобновление старого сеанса почти всегда делает то же самое: кэш к тому времени обычно уже исчез, а системный промпт всё равно пересобирается при запуске.

Всё это не означает, что Вам никогда не следует переключать модели или уровень усилий. Это означает, что есть дешёвые моменты для этого — начало сеанса или сразу после \/clear, — и дорогие — середина длинного разговора.

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

От чего зависит, сколько токенов отправляет сеанс

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

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

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

Что оказывается в контексте

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

Совет: запустите /context в новом сеансе, чтобы увидеть, что там есть, прежде чем Вы что-либо введёте. Оставьте в CLAUDE.md только конкретные инструкции, а инструкции, относящиеся к конкретным рабочим процессам, перенесите в навыки, которые загружаются только при использовании. Если в этом сеансе есть сервер MCP, который Вам не нужен, отключите его с помощью /mcp.

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

Объём того, что читает Claude, в основном сводится к тому, как много ему приходится выяснять самостоятельно. Если Вы скажете «тесты не проходят», сначала ему нужно выяснить, какие именно тесты: один-два поиска grep, несколько открытых файлов, чтобы понять, какой из них релевантен, и все эти результаты остаются в контексте ещё долго после того, как перестали быть полезными.

«Исправьте непроходящий тест в utils.test.ts» позволяет пропустить поиск и обходится одним вызовом Read для файла, а «Исправьте непроходящий тест в @utils.test.ts» не требует даже вызова Read.

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

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

На самом деле очень большие выводы — это нормально: после 30 000 символов Claude Code записывает вывод в файл и помещает в диалог только короткий предварительный просмотр и путь (BASH_MAX_OUTPUT_LENGTH, если Вы хотите это изменить). 

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

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

Совет: поместите две или три команды, которые Вы выполняете весь день, в CLAUDE.md, включая флаги для тихого вывода, так, как Вы набрали бы их сами («запустить один файл тестов с npx vitest run --reporter=dot»). Это небольшое дополнение, но оно экономит один ход и несколько сотен строк вывода в каждом последующем сеансе.

Сколько ходов это там остаётся

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

Совет: выполните /rename перед /clear , если позже Вы захотите вернуть сеанс. Когда Вы выполняете /compact, укажите, что нужно сохранить, или добавьте раздел «Инструкции по сжатию» в CLAUDE.md, если это всегда одно и то же. А если Вы используете модель 1M и предпочли бы иметь страховочную сетку автоматического сжатия там, где она была раньше, /autocompact 200k возвращает её (требуется Claude Code v2.1.221+).

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

Субагенты

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

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

Это окупается, когда задача производит много вывода, который Вам не нужно сохранять, например при просмотре журнала. Claude часто сам обращается к субагенту для таких вещей, и Вы можете попросить об этом напрямую, когда он этого не делает («пройди по этому журналу в субагенте»). Просто помните, что основной сеанс получает обратно только то, что субагент решил сообщить.

Совет: если есть шумная задача, которую Вы снова и снова передаёте, дайте ей собственное определение субагента с model: haiku (или sonnet). Иначе она выполняется на той же модели, на которой работает Ваш основной сеанс.

Куда смотреть в первую очередь

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