# Как экономить токены в Claude Code и не терять эффективность
Канонический URL: https://zero2claude.ru/blog/effektivnye-sessii-claude-code
Дата: 2026-08-14
Теги: claude-code, автоматизация, агенты, api
Разбираемся, из чего складывается стоимость токена в Claude Code и как без потери качества сократить расходы на рутинные задачи.
Раньше инструменты для программирования стоили одинаково независимо от того, чем ты занят. Твой редактор кода брал одну и ту же плату (а часто вообще ничего), хотел ты исправить один тест или пятьдесят за вечер. У отдельной задачи просто не было своей цены.
С агентными инструментами вроде Claude Code всё иначе. Цена появилась — и одна и та же выполненная задача может стоить по-разному в зависимости от того, как именно ты её попросил сделать. В одной сессии Claude читает тест и файл, который он покрывает, вносит правку и укладывается в пару реплик. В другой — сначала бродит по репозиторию с grep, попутно читает десяток файлов, прежде чем добраться до тех же двух нужных, и весь этот груз тащится за собой во все последующие реплики сессии.
Результат одинаковый — фикс сделан. А вот количество потраченных токенов разное, и всё это время модели приходилось держать в голове десять файлов, которые ей были не нужны. Экономия токенов не означает «использовать их меньше вообще». Она означает — сделать так, чтобы те токены, которые ты уже потратил, шли на то, что ты действительно просил.
## Из чего складывается цена токена
Формально ты платишь за токены, но по факту платишь за инференс — время, которое GPU (или TPU) тратит на обработку твоих токенов. На это время влияют три фактора: какая модель работает, входящий это токен или исходящий, и был ли он взят из кэша.
Модель — самый очевидный множитель: чем крупнее модель, тем больше работы она делает над каждым токеном, что на входе, что на выходе. Все остальные факторы, о которых пойдёт речь ниже, умножаются именно на цену модели, поэтому большую модель стоит включать для по-настоящему сложных или неоднозначных задач, а маленькую — для рутины.
### Входные и выходные токены стоят по-разному
Запрос проходит через GPU в две фазы, и они не равны по цене. Сначала идёт prefill — модель читает твой запрос и весь контекст: системный промпт, CLAUDE.md, твоё сообщение и всё, что уже накопилось в диалоге (файлы, которые Claude прочитал, вывод команд, которые он запускал). Это входные токены.
Дальше — decode: модель пишет выходные токены, свои размышления, вызовы инструментов, финальный текст. Происходит это по одному токену за раз: ответ на 200 токенов — это 200 последовательных прогонов модели. Поэтому на каждый токен decode занимает GPU намного дольше, и выходные токены стоят примерно в 5 раз дороже входных.
Значительная часть выходных токенов в сессии — это токены размышлений, а сколько модель «думает» за реплику, регулирует уровень effort. Как и модель, выбранный уровень effort запоминается и переносится в следующую сессию по умолчанию — так что стоит один раз командой /model и /effort проверить, на чём ты сейчас работаешь, а не гадать. Если знаешь, что сессия предстоит чисто механическая, переменная `MAX_THINKING_TOKENS=0` выключает размышления совсем — это ступенька ниже, чем /effort low.
## Как работает кэширование промптов
Если запрос начинается ровно с тех же токенов, что и предыдущий, сервер может не пересчитывать их состояние заново, а достать его из памяти — и просчитать только то, что добавилось после. Это и называется кэшированием промптов.
Чтение из кэша стоит 0,1x от обычной цены входного токена — сервер просто загружает готовое состояние вместо вычислений. Запись в кэш стоит немного дороже обычного входа, до 2x, потому что сервер после этого хранит это состояние. Но запись случается один раз на токен, а дешёвые чтения происходят на каждой следующей реплике. Claude Code управляет этим кэшем автоматически, включать ничего не нужно — но важно знать, как его случайно не сломать.
Разберём на примере фразы «исправь падающий тест в utils.test.ts»:
1. Claude Code собирает первый запрос из системного промпта, CLAUDE.md и твоего сообщения. В кэше пока ничего нет, поэтому всё считается с нуля и записывается в кэш.
2. Модель не может исправить тест, которого не видела, — она думает и делает Read-вызов для utils.test.ts. Claude Code читает файл, добавляет его в разговор и отправляет всё снова. Всё из первого запроса читается из кэша по десятой цене, полную цену платим только за новое — вызов Read и сам файл.
3. Модели нужен файл, который тестируется. Ещё один Read, ещё одно добавление — первые два запроса из кэша, второй файл по полной цене.
4. Модель делает Edit. Claude Code применяет правку, добавляет результат, отправляет всё заново — всё старое из кэша, новое по полной цене.
5. Модель запускает `npm test`. Вывод теста добавляется как единственная новая часть.
6. Тесты прошли, модель отвечает коротким резюме. Новых вызовов инструментов нет — значит, нет и нового запроса.
Пять запросов ради одного маленького фикса, и каждый из них содержал весь разговор целиком. Типичная реплика при этом устроена «однобоко»: десятки тысяч токенов на входе, пара сотен на выходе. Но полную цену платишь только за то, что действительно новое в этой реплике — остальное дешёвые чтения из кэша.
Это работает и на подписке: цены ты напрямую не видишь, но точно те же запросы «съедают» твои лимиты. Важно понимать, что именно сбрасывает кэш:
| Действие | Что происходит с кэшем |
|---|---|
| Смена /model | У каждой модели свой кэш — весь разговор пересчитывается по полной цене |
| Смена /effort | Effort входит в ключ кэша — та же история, поэтому обе команды просят подтверждение при смене в середине диалога |
| Включение fast mode | Тоже часть ключа, пересчёт идёт по ценам fast mode — включай сразу в начале сессии |
| /compact | Разговор заменяется коротким резюме — старое содержимое больше не совпадает, дешевле делать это пока старый диалог ещё в кэше |
| Долгая пауза | Кэш живёт час на подписке и 5 минут по API-ключу (можно продлить до часа переменной `ENABLE_PROMPT_CACHING_1H=1`) |
Если последние реплики увели диалог не туда, используй /rewind, чтобы отрезать именно их, а не /compact. Rewind просто откатывает конец разговора — всё, что было до него, остаётся в кэше и ничего не стоит. Compact пересобирает весь диалог заново, а значит, платит за это всегда.
## Что определяет, сколько токенов уходит за сессию
Главное, что нужно понимать: ничего в контексте не отправляется один раз. Всё, что попало в разговор — прочитанный файл или вывод команды — будет отправляться заново на каждой следующей реплике до конца сессии. Это дешёвые повторные чтения из кэша, но дешёвые — не значит бесплатные, и они всё равно занимают место в контексте, вокруг которого модели приходится «думать» на каждом шаге.
Часть контекста загружается ещё до того, как ты вообще что-то напечатал: определения инструментов, системный промпт, CLAUDE.md и всё, что подключается при старте. Команда /context в свежей сессии покажет, что там уже лежит — стоит посмотреть один раз, чтобы понять, что можно убрать. Держи CLAUDE.md компактным и конкретным, а рабочие сценарии выноси в [навыки](/blog/claude-skills) — они подгружаются только тогда, когда реально нужны. Ненужный в этой сессии MCP-сервер можно временно выключить командой /mcp.
Остальное, что копится во время сессии, — это результаты работы инструментов: файлы, которые Claude прочитал, и вывод команд, которые он запустил. Объём прочитанного напрямую зависит от того, сколько модели приходится выяснять самостоятельно. Фраза «тесты не проходят» вынуждает её сперва искать — пара grep-запросов, несколько открытых файлов, и всё это остаётся в контексте задолго после того, как перестало быть нужным. А фраза «исправь падающий тест в utils.test.ts» пропускает поиск и обходится одним Read-вызовом, а «исправь падающий тест в @utils.test.ts» экономит даже его.
Claude Code прикрепляет файл к сообщению до отправки, так что он оказывается в самом первом запросе без отдельного Read-вызова. Файл занимает то же место в контексте в любом случае, так что @-упоминать его повторно на следующей реплике обычно не нужно — это просто создаст вторую копию.
Вывод шумных команд — вторая большая статья расходов. Он добавляется в разговор точно так же, как файл, и остаётся там до конца сессии. Если команда обычно выдаёт много лишнего текста, добавь к ней «тихий» флаг или запусти её в [субагенте](/blog/subagents-in-practice) — тогда в основной разговор попадёт только итоговый результат, а не весь поток логов.
## Шесть привычек для эффективной сессии
Собрав всё вместе, получается небольшой набор привычек, которые реально снижают счёт без потери качества работы:
| Привычка | Почему это помогает |
|---|---|
| /clear между задачами | Не тащишь неактуальный контекст в новую задачу, меньше лишних токенов на каждую реплику |
| Модель и effort — до старта | Смена посреди диалога сбрасывает кэш и пересчитывает всё по полной цене |
| @-упоминай файлы вместо имени | Файл прикрепляется сразу, без отдельного Read-вызова или поиска |
| Тихие флаги / субагенты для шумных команд | Вывод команды остаётся в контексте на всю сессию — лучше не копить в нём лишнее |
| /context в свежей сессии | Видно, что загружено по умолчанию, можно убрать ненужное |
| /compact перед перерывом | Кэш живёт около часа, сжимать разговор дешевле, пока он ещё в кэше |
Ничего из этого не значит, что нужно экономить токены в ущерб результату — задача не «тратить меньше», а «тратить туда, куда просил». Иногда правильный выбор — крупная модель и высокий effort, если проблема действительно сложная. А вот рутинные правки, поиск опечаток или мелкие фиксы вполне можно доверить меньшей модели с низким effort — разница в качестве почти не почувствуется, а разница в цене будет заметной. Если тебе только предстоит освоиться с терминалом и агентными инструментами вообще, можно начать с бесплатного курса zero2claude — там разбираются базовые команды и логика работы с Claude Code с нуля.
## Частые вопросы
Это механизм, при котором сервер запоминает состояние обработки начала запроса и не пересчитывает его заново, если следующий запрос начинается с тех же токенов. В Claude Code кэш управляется автоматически — включать его не нужно, важно только не ломать случайно (например, сменой модели или effort посреди разговора).
Входные токены обрабатываются во время prefill — модель читает весь контекст сразу. Выходные генерируются во время decode по одному токену за раз, и каждый такой шаг держит GPU занятым дольше. Поэтому выходные токены стоят примерно в 5 раз дороже входных.
/rewind просто отрезает последние реплики, которые пошли не туда, а всё, что было до них, остаётся в кэше — это бесплатно. /compact пересобирает весь разговор в короткое резюме, и это всегда что-то стоит, хотя дешевле сделать это пока старый разговор ещё в кэше, то есть до долгого перерыва, а не после него.
Команда /context в свежей сессии показывает, что уже загружено: системный промпт, CLAUDE.md, определения MCP-инструментов. Это удобная отправная точка, чтобы убрать всё ненужное — например, отключить лишний MCP-сервер командой /mcp или перенести часть инструкций из CLAUDE.md в отдельные навыки.
Если хочешь попробовать всё это руками — начни с бесплатного курса [«Claude Code и терминал: с 0»](/learn/code-terminal).
По мотивам статьи Anthropic «Maximizing the value of your Claude Code sessions». Пересказали по-русски для новичков.