TL;DR

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

Как получить максимум ценности

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

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

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

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

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

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

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

Оплата идёт за токен, но по сути платят за инференс — время, которое GPU (или TPU, или что там используется под капотом) тратит на прогон модели через ваши токены.

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

Модель

Более крупная модель выполняет больше работы как на входных, так и на выходных токенах. Какая модель оправдана для какой задачи — отдельная тема, подробно разобранная в материале Choosing a Claude model and effort level in Claude Code.

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

Кривые приведены исключительно для иллюстрации и не отражают реальные данные бенчмарков.

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

Запрос проходит через GPU в две фазы, и они стоят по-разному.

Сначала, на этапе prefill, модель читает запрос и контекст: системный промпт, CLAUDE.md, сообщение и всё, что добавилось в разговор с тех пор — файлы, которые прочитал Claude, и вывод выполненных команд. Это входные токены.

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

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

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

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

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

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

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 просят подтверждения при переключении посреди разговора.
  • Fast mode: тоже часть ключа, и повторное вычисление происходит по ценам fast mode — так что включать его стоит в начале сессии. (Выключение обратно бесплатно с точки зрения кэша.)
  • /compact: разговор заменяется более коротким, поэтому ничего в нём больше не совпадает (системный промпт перед ним сохраняется). Само создание резюме дёшево, пока старый разговор ещё в кэше, поэтому делать это гораздо дешевле перед долгим перерывом, чем после него.
  • Время: каждый шаг сбрасывает таймер, но кэш истекает через час на подписке или через пять минут при использовании API-ключа (ENABLE_PROMPT_CACHING_1H=1 продлевает срок до часа). Если вернуться позже, следующий шаг заново вычислит весь разговор. Возобновление старой сессии почти всегда работает так же: к тому моменту кэш обычно уже истёк, а системный промпт всё равно пересобирается при запуске.

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

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

Что определяет, сколько токенов отправляет сессия

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

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

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

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

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

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

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

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

Формулировка «Почини падающий тест в utils.test.ts» пропускает поиск и стоит одного вызова Read для файла, а «Почини падающий тест в @utils.test.ts» не стоит даже этого вызова.

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

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

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

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

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

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

Сколько шагов это остаётся в контексте

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

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

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

Субагенты

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

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

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

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

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

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