Раньше инструменты для программирования стоили одинаково независимо от того, чем ты занят. Твой редактор кода брал одну и ту же плату (а часто вообще ничего), хотел ты исправить один тест или пятьдесят за вечер. У отдельной задачи просто не было своей цены.
С агентными инструментами вроде 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»:
- Claude Code собирает первый запрос из системного промпта, CLAUDE.md и твоего сообщения. В кэше пока ничего нет, поэтому всё считается с нуля и записывается в кэш.
- Модель не может исправить тест, которого не видела, — она думает и делает Read-вызов для utils.test.ts. Claude Code читает файл, добавляет его в разговор и отправляет всё снова. Всё из первого запроса читается из кэша по десятой цене, полную цену платим только за новое — вызов Read и сам файл.
- Модели нужен файл, который тестируется. Ещё один Read, ещё одно добавление — первые два запроса из кэша, второй файл по полной цене.
- Модель делает Edit. Claude Code применяет правку, добавляет результат, отправляет всё заново — всё старое из кэша, новое по полной цене.
- Модель запускает
npm test. Вывод теста добавляется как единственная новая часть. - Тесты прошли, модель отвечает коротким резюме. Новых вызовов инструментов нет — значит, нет и нового запроса.
Пять запросов ради одного маленького фикса, и каждый из них содержал весь разговор целиком. Типичная реплика при этом устроена «однобоко»: десятки тысяч токенов на входе, пара сотен на выходе. Но полную цену платишь только за то, что действительно новое в этой реплике — остальное дешёвые чтения из кэша.
Это работает и на подписке: цены ты напрямую не видишь, но точно те же запросы «съедают» твои лимиты. Важно понимать, что именно сбрасывает кэш:
| Действие | Что происходит с кэшем |
|---|---|
| Смена /model | У каждой модели свой кэш — весь разговор пересчитывается по полной цене |
| Смена /effort | Effort входит в ключ кэша — та же история, поэтому обе команды просят подтверждение при смене в середине диалога |
| Включение fast mode | Тоже часть ключа, пересчёт идёт по ценам fast mode — включай сразу в начале сессии |
| /compact | Разговор заменяется коротким резюме — старое содержимое больше не совпадает, дешевле делать это пока старый диалог ещё в кэше |
| Долгая пауза | Кэш живёт час на подписке и 5 минут по API-ключу (можно продлить до часа переменной ENABLE_PROMPT_CACHING_1H=1) |
Совет
Если последние реплики увели диалог не туда, используй /rewind, чтобы отрезать именно их, а не /compact. Rewind просто откатывает конец разговора — всё, что было до него, остаётся в кэше и ничего не стоит. Compact пересобирает весь диалог заново, а значит, платит за это всегда.
Что определяет, сколько токенов уходит за сессию
Главное, что нужно понимать: ничего в контексте не отправляется один раз. Всё, что попало в разговор — прочитанный файл или вывод команды — будет отправляться заново на каждой следующей реплике до конца сессии. Это дешёвые повторные чтения из кэша, но дешёвые — не значит бесплатные, и они всё равно занимают место в контексте, вокруг которого модели приходится «думать» на каждом шаге.
Часть контекста загружается ещё до того, как ты вообще что-то напечатал: определения инструментов, системный промпт, CLAUDE.md и всё, что подключается при старте. Команда /context в свежей сессии покажет, что там уже лежит — стоит посмотреть один раз, чтобы понять, что можно убрать. Держи CLAUDE.md компактным и конкретным, а рабочие сценарии выноси в навыки — они подгружаются только тогда, когда реально нужны. Ненужный в этой сессии MCP-сервер можно временно выключить командой /mcp.
Остальное, что копится во время сессии, — это результаты работы инструментов: файлы, которые Claude прочитал, и вывод команд, которые он запустил. Объём прочитанного напрямую зависит от того, сколько модели приходится выяснять самостоятельно. Фраза «тесты не проходят» вынуждает её сперва искать — пара grep-запросов, несколько открытых файлов, и всё это остаётся в контексте задолго после того, как перестало быть нужным. А фраза «исправь падающий тест в utils.test.ts» пропускает поиск и обходится одним Read-вызовом, а «исправь падающий тест в @utils.test.ts» экономит даже его.
Упоминай файлы через @
Claude Code прикрепляет файл к сообщению до отправки, так что он оказывается в самом первом запросе без отдельного Read-вызова. Файл занимает то же место в контексте в любом случае, так что @-упоминать его повторно на следующей реплике обычно не нужно — это просто создаст вторую копию.
Вывод шумных команд — вторая большая статья расходов. Он добавляется в разговор точно так же, как файл, и остаётся там до конца сессии. Если команда обычно выдаёт много лишнего текста, добавь к ней «тихий» флаг или запусти её в субагенте — тогда в основной разговор попадёт только итоговый результат, а не весь поток логов.
Шесть привычек для эффективной сессии
Собрав всё вместе, получается небольшой набор привычек, которые реально снижают счёт без потери качества работы:
| Привычка | Почему это помогает |
|---|---|
| /clear между задачами | Не тащишь неактуальный контекст в новую задачу, меньше лишних токенов на каждую реплику |
| Модель и effort — до старта | Смена посреди диалога сбрасывает кэш и пересчитывает всё по полной цене |
| @-упоминай файлы вместо имени | Файл прикрепляется сразу, без отдельного Read-вызова или поиска |
| Тихие флаги / субагенты для шумных команд | Вывод команды остаётся в контексте на всю сессию — лучше не копить в нём лишнее |
| /context в свежей сессии | Видно, что загружено по умолчанию, можно убрать ненужное |
| /compact перед перерывом | Кэш живёт около часа, сжимать разговор дешевле, пока он ещё в кэше |
Ничего из этого не значит, что нужно экономить токены в ущерб результату — задача не «тратить меньше», а «тратить туда, куда просил». Иногда правильный выбор — крупная модель и высокий effort, если проблема действительно сложная. А вот рутинные правки, поиск опечаток или мелкие фиксы вполне можно доверить меньшей модели с низким effort — разница в качестве почти не почувствуется, а разница в цене будет заметной. Если тебе только предстоит освоиться с терминалом и агентными инструментами вообще, можно начать с бесплатного курса zero2claude — там разбираются базовые команды и логика работы с Claude Code с нуля.
Частые вопросы
Что такое prompt caching и нужно ли включать его вручную?
Это механизм, при котором сервер запоминает состояние обработки начала запроса и не пересчитывает его заново, если следующий запрос начинается с тех же токенов. В Claude Code кэш управляется автоматически — включать его не нужно, важно только не ломать случайно (например, сменой модели или effort посреди разговора).
Почему выходные токены дороже входных?
Входные токены обрабатываются во время prefill — модель читает весь контекст сразу. Выходные генерируются во время decode по одному токену за раз, и каждый такой шаг держит GPU занятым дольше. Поэтому выходные токены стоят примерно в 5 раз дороже входных.
Когда лучше использовать /compact, а когда /rewind?
/rewind просто отрезает последние реплики, которые пошли не туда, а всё, что было до них, остаётся в кэше — это бесплатно. /compact пересобирает весь разговор в короткое резюме, и это всегда что-то стоит, хотя дешевле сделать это пока старый разговор ещё в кэше, то есть до долгого перерыва, а не после него.
Как понять, что грузится в контекст перед началом работы?
Команда /context в свежей сессии показывает, что уже загружено: системный промпт, CLAUDE.md, определения MCP-инструментов. Это удобная отправная точка, чтобы убрать всё ненужное — например, отключить лишний MCP-сервер командой /mcp или перенести часть инструкций из CLAUDE.md в отдельные навыки.
Если хочешь попробовать всё это руками — начни с бесплатного курса «Claude Code и терминал: с 0».
Источник
По мотивам статьи Anthropic «Maximizing the value of your Claude Code sessions». Пересказали по-русски для новичков.