Как не жечь лимиты в Claude Code

1.За что ты платишь

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

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

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

2.Замерь свой расход — не угадывай

Прежде чем что-то менять, посмотри, куда именно уходят токены. Claude Code пишет каждую сессию в ~/.claude/projects/, и там есть честные счётчики. Скопируй в файл usage.py и запусти:

import json, glob, os, collections

root = os.path.expanduser("~/.claude/projects")
agg = collections.defaultdict(lambda: collections.defaultdict(int))

for fp in glob.glob(os.path.join(root, "**", "*.jsonl"), recursive=True):
    with open(fp, errors="replace") as f:
        for line in f:
            if '"usage"' not in line:
                continue
            try:
                d = json.loads(line)
            except Exception:
                continue
            msg = d.get("message") or {}
            u = msg.get("usage") or {}
            if not u:
                continue
            a = agg[msg.get("model") or "?"]
            a["вход"]        += u.get("input_tokens", 0) or 0
            a["выход"]       += u.get("output_tokens", 0) or 0
            a["запись кэша"] += u.get("cache_creation_input_tokens", 0) or 0
            a["чтение кэша"] += u.get("cache_read_input_tokens", 0) or 0

for model, a in sorted(agg.items(), key=lambda kv: -sum(kv[1].values())):
    total = sum(a.values()) or 1
    print(f"\n{model}: всего {total/1e6:.1f} млн токенов")
    for k, v in sorted(a.items(), key=lambda kv: -kv[1]):
        print(f"   {k:14} {v/1e6:9.1f} млн   {100*v/total:5.1f}%")

Читается так. Если «чтение кэша» занимает львиную долю — а в многосессионной работе это обычно 90 % и больше, — значит твои лимиты уходят не на генерацию, а на тёплый контекст: модель час за часом перечитывает одно и то же. Лечится это чисткой сессий и делегированием (пункты 3, 6 и 7), а не попытками писать лаконичнее. Если же непропорционально велик «выход», ты гонишь через Claude Code генерацию длинных текстов — смотри пункт 8.

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

3.Чистка сессии вместо /compact

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

Дешевле так:

1. Довёл дело до логической точки.
2. Попроси: «запиши в handoff.md: что сделано, где остановились, точный следующий шаг, какие файлы трогали».
3. /clear.
4. Новая сессия начинается с «прочитай handoff.md, продолжаем».

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

Одна сессия — одна задача. Не тащи в один чат три темы: потом каждая реплика по третьей теме оплачивает историю первой и второй.

4.MCP-серверы — тихий пожиратель

Описания инструментов каждого подключённого MCP-сервера уходят в контекст на каждом запросе. Десяток серверов — это легко десятки тысяч токенов на пустом месте, ещё до того, как ты что-нибудь написал. И они же сбивают кэш, когда ты их подключаешь или отключаешь на ходу.

Посмотри /mcp и оставь только то, чем пользуешься в этой задаче. Остальное — убрать из конфига. Если какой-то сервер нужен редко, но нужен, держи его в отдельном профиле конфигурации и включай под задачу.

5.CLAUDE.md держать коротким

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

Рабочая схема — ядро и ссылки. В CLAUDE.md остаётся только то, что нужно в каждой сессии: пара абзацев про проект, жёсткие запреты, как запускать. Всё остальное выносится в отдельные файлы (docs/rules/*.md), а в ядре стоит одна строка: «перед работой по теме X читать такой-то файл». Модель прочитает его тогда, когда дойдёт до темы, а не 200 раз в день впустую.

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

6.Модель под задачу — и как сделать это автоматом

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

Руками это /model. Но руками ты будешь забывать, поэтому настрой один раз:

Субагент с прописанной моделью

Положи файл ~/.claude/agents/log-digest.md:

---
name: log-digest
description: Прочитать длинный лог прогона и вернуть ТОЛЬКО сводку дефектов.
  Брать всегда, когда нужно "посмотри, что в логе" — вместо
  чтения лога в основной сессии.
tools: Bash, Read, Grep, Glob
model: haiku
---

Ты читаешь машинный лог и возвращаешь сводку. Текст лога в ответ не копируешь.

1. Сначала размер и форма: wc -l, head -40, tail -40. Большой лог читать грепом,
   целиком в контекст не тянуть.
2. Посчитать популяцию: сколько обработано, сколько ОК, сколько упало. Числа брать
   из лога, не оценивать на глаз.
3. Дефекты по типам: тип -> сколько раз -> 2-3 примера с номером строки.

## Правило отказа — важнее самой задачи
Остановись и верни отчёт с пометкой "НУЖНА СТАРШАЯ МОДЕЛЬ", если: задача требует
решения, а не проверки; данные противоречат друг другу; ты собираешься исключить
часть популяции из проверки; найденное не похоже ни на один ожидаемый тип.
"Не знаю" и "N из M" — полноценный результат. Выдуманная уверенность — брак.

Поле model принимает haiku, sonnet, opus или inherit. Теперь, когда ты говоришь «посмотри, что в логе», работа уходит в отдельный контекст на дешёвой модели, а в основную сессию возвращается десяток строк вместо сорока мегабайт.

Дефолт для всех фоновых агентов

По умолчанию субагент наследует модель основной сессии — то есть твоя старшая модель незаметно работает в фоне. Это чинится одной строкой в ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "sonnet"
  }
}

Приоритет такой: модель, указанная при вызове → model: в файле агента → эта переменная → модель основной сессии. Есть ещё CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1, который сажает на одну модель вообще всех, перебивая model: в файлах агентов — не советую: тогда и агент, которому нужен Sonnet, поедет на нижней планке. Пусть планку задаёт сам агент.

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

Почему дешёвой модели нужно «правило отказа»

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

Поэтому защиту строит тот, кто делегирует:

• Задание механическое. Дешёвой модели — проверка, а не решение. Что считать дефектом и трогать ли прод — не её вопрос.
• Правило отказа в файле агента (см. пример выше): «не знаю» объявлено нормальным результатом, выдуманная уверенность — браком.
• Контроли в каждом прогоне. Подсунь заведомо хороший и заведомо битый случай. Сломанный, но уверенный агент ловится контролями независимо от модели.
• Перепроверка выводов. Отчёт агента — это данные, а не истина. Каждую его тревогу подтверждай своим запросом, прежде чем принимать решение.
• Гибрид по умолчанию: факты собирает дешёвая модель, вывод делает старшая. Если задача не делится на «собрать» и «решить» — не отдавай её дешёвой вовсе.

Это не теория: на механической задаче с подложенными ловушками младшая модель с таким правилом честно останавливается и говорит «проверено 28 из 30, контрольный тест провален, решать не мне». Без правила — уверенно рапортует, что всё хорошо.

7.Делегируй чтение, а не читай сам

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

И три привычки, которые экономят больше, чем кажется:

• Не давать читать файлы целиком. «Посмотри этот файл» на три тысячи строк — это десятки тысяч токенов в контексте навсегда. Проси grep, sed -n, head.
• Обрезать вывод команд. | head -50. Иначе простыня из терминала оседает в контексте до конца сессии.
• Указывать пути. Если не сказать, где лежит, агент пойдёт искать по репозиторию и прочитает десяток файлов «на всякий случай». Одна строчка «это в src/x/y.ts» дешевле любого поиска.

8.Длинные тексты генерируй не здесь

Если задача — «напиши две главы» или «сделай 50 описаний товаров», это тысячи выходных токенов, и каждая итерация правок тянет за собой весь накопленный контекст. Claude Code — дорогой инструмент для такой работы.

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

9.Формулируй задачу целиком сразу

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

И отдельно: не проси «перепроверь всё ещё раз». Повторный полный проход стоит как первый. Если нужна проверка — сузь её: «проверь только эти три файла и только на вот это».

10.Мелочи, которые копятся

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

11.Если лимит всё-таки кончился

Три варианта, по убыванию разумности.

Платить за перерасход на том же аккаунте

В Claude Code есть /usage-credits. Включённые usage credits означают: когда включённый лимит плана выбран, запросы продолжают работать по стандартному тарифу API — в том же аккаунте, с теми же сессиями, файлами и настройками. Работа не встаёт. Ограничители — месячный лимит траты, который ты сам задаёшь, и баланс.

Два подвоха. Первый: при аутентификации по API-ключу эта команда недоступна. Второй, и он дороже: если в окружении выставлена переменная ANTHROPIC_API_KEY, Claude Code молча пойдёт по ней вместо подписки и начнёт выставлять счёт по API, пока ты думаешь, что работаешь по плану. Проверь echo $ANTHROPIC_API_KEY, прежде чем удивляться счёту.

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

Поставить дешёвую модель и работать дальше

Это не отдельный инструмент: та же сессия, /model → младшая модель. Качество просядет, дисциплина, файлы и настройки останутся. Разумный аварийный режим, чтобы дожать то, что начато, и нормально закрыть день через handoff.md.

Сторонние прокси к бесплатным моделям

Есть проекты, которые подменяют Claude Code бэкенд и гоняют запросы в бесплатные тарифы сторонних провайдеров. Честно про них: харнесс они сохраняют — твои CLAUDE.md, файлы, агенты, инструменты остаются на месте, меняется только модель. Но:

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

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

12.Чек-лист