Как снизить расход токенов Claude: полное руководство для разработчиков и вайбкодеров"

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

На практике это означает, что расход токенов растёт квадратично с длиной разговора. Длинная сессия, подключённые MCP-инструменты, большой CLAUDE.md, расширенное мышление (extended thinking) — всё это незаметно суммируется и в итоге превращается в счёт, который удивляет.

Команда Branch8 задокументировала оптимизацию: в первый месяц они потратили $2 400 (около 240 миллионов токенов). После внедрения оптимизаций к третьему месяцу расходы составили $680 — снижение на 72%.

Разберём всё по порядку: от самого очевидного (выбор модели) до тонких, но значимых вещей (правильное время для /compact и структура CLAUDE.md).

## Почему вы тратите больше, чем думаете

Прежде чем оптимизировать — стоит понять откуда вообще берутся токены, потому что интуиция здесь часто подводит.

Системный промпт загружается всегда. CLAUDE.md загружается до того, как Claude прочитал ваш код, до того, как прочитал задачу, до всего. 5 000-токенный CLAUDE.md стоит 5 000 токенов на каждом ходу, каждой сессии. Постоянная базовая стоимость, которую вы несёте всё время.

Инструменты и MCP-коннекторы тоже занимают место. Каждый MCP-коннектор (Google Drive, Slack, Calendar и т.д.) и каждый включённый инструмент загружает своё полное определение в контекстное окно при каждом сообщении — используете вы его или нет. Если у вас подключено 5 коннекторов и вы не используете ни один из них для задачи с кодом — вы тратите тысячи токенов на сообщение просто на определения инструментов.

Выходные токены стоят в 5 раз дороже входных. Выходные токены оплачиваются ровно в пять раз по ставке входных токенов в текущем API Anthropic. Вы платите за 2 000-словный ответ, который вам не был нужен, несколько раз: один раз когда он написан, и один раз при каждом последующем ходу, который его перечитывает.

Extended thinking по умолчанию включён. Extended thinking включён по умолчанию, потому что значительно улучшает производительность на сложных задачах планирования и рассуждения. Токены мышления оплачиваются как выходные токены, и бюджет по умолчанию может составлять десятки тысяч токенов на запрос в зависимости от модели.

## Слой 1: выбор модели — самый большой рычаг

Это самое важное решение, от которого зависит 50-70% итоговой стоимости. Не каждая задача требует мощнейшей модели.

### Текущие цены и возможности

*Introductory pricing до 31 августа 2026, затем стандартные цены.

Haiku обходится в 15 раз дешевле Opus по входным токенам и в 5 раз дешевле Sonnet. Для задач вроде «переименовать переменную по всему файлу» или «конвертировать JSON в TypeScript-интерфейс» — Haiku абсурдно дёшев и абсурдно быстр.

### Правило выбора модели

Задача механическая (переименование, форматирование, простые Q&A) → Haiku
Задача стандартная (большинство кодирования, мультифайловая логика) → Sonnet 5
Задача сложная (архитектура, нетривиальный рефакторинг) → Opus 4.8

Там, где Haiku ломается — задачи, которые выглядят простыми, но требуют читать код и принимать решения. Он даёт неверные ответы быстрее, что обходится вам циклом исправления. В сомнительных случаях Sonnet — надёжная золотая середина.

### opusplan: Opus для планирования, Sonnet для реализации

Если вам нужна рассуждение уровня Opus, но вы хотите контролировать расходы, псевдоним модели opusplan предоставляет автоматизированный гибридный подход: Claude использует Opus во время режима планирования для сложных рассуждений и архитектурных решений, затем автоматически переключается на Sonnet для генерации кода и реализации.

В Claude Code это команда /model opusplan — вы платите за Opus только на этапе составления плана, а вся дальнейшая работа выполняется на Sonnet.

## Слой 2: уровни effort — управление глубиной мышления

Параметр effort позволяет напрямую контролировать сколько токенов Claude тратит на обдумывание ответа. Это один из самых быстрых способов снизить расходы без смены модели.

### Пять уровней

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

В Claude Code: команда /effort или настройка в /model.

Через API:

import anthropic

client = anthropic.Anthropic()

# Экономный вариант для простых задач
response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    effort="low",  # вместо high по умолчанию
    messages=[{"role": "user", "content": "Переименуй переменную foo в bar"}]
)

# Полная мощность для сложных задач
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=8192,
    effort="max",
    messages=[{"role": "user", "content": "Спроектируй архитектуру системы кэширования"}]
)

### Ограничение токенов мышления напрямую

Для моделей с фиксированным бюджетом мышления — ограничение через переменную окружения:

# Ограничить мышление до 8000 токенов вместо десятков тысяч по умолчанию
export MAX_THINKING_TOKENS=8000

Для более простых задач, где глубокое рассуждение не нужно, можно снизить расходы, понизив уровень effort с помощью /effort или в /model, отключив мышление в /config, или установив MAX_THINKING_TOKENS. Отключение мышления недоступно на Fable 5 — он всегда использует extended thinking.

## Слой 3: кэширование промптов — экономия до 90%

Кэширование промптов — самый высокодоходный инструмент если вы используете API напрямую.

### Как работает

Кэш write-токены стоят 1,25× стандартной ставки (единоразовая стоимость), но кэш read-токены стоят только 0,1× — скидка 90%. Если ваш системный промпт состоит из 10 000 токенов и вы делаете 100 API-вызовов, вы сэкономите примерно 990 000 токенов обработки.

ProjectDiscovery's агент Neo задокументировал 59% кумулятивное снижение только от кэширования промптов, доходящее до 90%+ на полностью оптимизированных путях.

### Правило структуры запроса

Статичный контент всегда должен идти первым, динамичный — последним:

1. Системные инструкции (кэшируются)
2. Схемы инструментов (кэшируются)
3. Контекст из базы знаний / документация (кэшируются)
4. Few-shot примеры (кэшируются)
5. Конкретное сообщение пользователя (НЕ кэшируется — меняется каждый раз)

### Реализация через Python SDK

import anthropic

client = anthropic.Anthropic()

# Системный промпт с кэшированием
response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": "Ты — старший Python-разработчик. Всегда пиши типизированный код...",
        "cache_control": {"type": "ephemeral"}  # ← включаем кэш
    }],
    messages=[{
        "role": "user",
        "content": "Напиши функцию валидации email"
    }]
)

Кэш живёт 5 минут с момента последнего использования (и продлевается при каждом обращении). Это значит: при активной работе с одним промптом кэш будет активен всё время сессии.

### В Claude Code

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

## ## Слой 4: управление контекстом — главный источник незаметного расхода

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

### /compact: когда и как

Своевременность важнее, чем люди думают. К тому моменту, когда Claude проверил несколько файлов, выполнил команды и исследовал несколько ложных следов, ваша сессия обычно содержит много материала, который больше не важен. Это правильный момент для compact. Распространённая ошибка — использовать /compact слишком поздно. Если compact выполнить раньше, пока сессия ещё «здорова», сводка будет намного лучше.

# Базовое сжатие
/compact

# С инструкцией что сохранить
/compact Сохрани только: принятые архитектурные решения, финальный код функций, открытые баги

# С фокусом на конкретное
/compact Focus on code samples and API usage

### /clear: между задачами

Когда переключаетесь на принципиально другую задачу — полная очистка дешевле, чем тащить весь контекст:

/rename "feature-auth-jwt"  # сначала переименовать для истории
/clear                      # затем очистить

### Контроль что попадает в контекст

CLAUDE.md: держите его компактным. 5 000 токенов в CLAUDE.md — это 5 000 токенов на каждом ходу каждой сессии навсегда. Оставьте только то, что действительно нужно при каждом запросе:

# Что ОСТАВИТЬ в CLAUDE.md:
- Архитектурные ограничения проекта
- Команды запуска тестов и сборки  
- Стиль кода (2-3 ключевых правила, не весь стайл-гайд)
- Директории, которые не нужно трогать

# Что УБРАТЬ из CLAUDE.md:
- Документация API (читается только при необходимости)
- Примеры кода (передавайте в запросе когда нужны)
- История проекта и контекст решений (в отдельный файл)

Инструменты и коннекторы: отключайте то, что не используете в текущей задаче. В claude.ai: кнопка «+» → Connectors → Tool access → выбрать только нужные для сессии.

### Прецизионное чтение файлов

Не просите Claude прочитать весь репозиторий — давайте только нужный контекст:

# Плохо — Claude прочитает всё
"Посмотри на проект и найди проблему"

# Хорошо — конкретный контекст
<relevant_code>
# paste only the relevant function
</relevant_code>
<error_output>
# paste only the relevant error  
</error_output>
<constraints>
- Не менять слой Redis кэширования
- Должно быть обратно совместимо с v2 API
</constraints>

## Слой 5: субагенты — изолировать «шумную» работу

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

Субагенты (.claude/agents/*.md) запускаются в собственных контекстных окнах. Задача «проверь 30 файлов на нарушения стиля» загрязнила бы главную сессию огромным контекстом. Субагент изолирует этот шум и возвращает только: «Найдено 12 нарушений, вот список».

# Создать субагента для ресурсоёмкой задачи
/agents create code-reviewer
"Проверь директорию /src на соответствие нашим стандартам кодирования. 
Верни только список файлов с нарушениями и конкретные строки."

Вместо того чтобы Claude тащил все 30 файлов в главный контекст — субагент работает изолированно, главная сессия остаётся лёгкой.

## Слой 6: структура промптов — точность как компрессия

Вялые или неясные промпты ведут к более плохой работе. Расплывчатый 15-словный промпт, вынуждающий Claude задать три уточняющих вопроса, обходится дороже по итогу, чем точный 60-словный промпт, который работает с первого раза.

Это counter-intuitive, но важно: экономить токены на промпте — плохая идея, если это приводит к некачественному ответу и циклу переспрашивания. Более длинный, но точный промпт в итоге дешевле.

Разделяйте системный промпт и пользовательский запрос:

# Плохо: дублирование инструкций в каждом запросе
user_message = "Ты — эксперт по безопасности. Ты — эксперт по безопасности. Проверь этот код..."

# Хорошо: разделение
system = "Ты — старший специалист по безопасности. Анализируй по стандартам OWASP."
user = "Проверь этот код на уязвимости."

Ограничивайте длину ответа явно:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=512,  # не 4096 если нужен короткий ответ
    messages=[...]
)

Используйте stop sequences чтобы не платить за лишние токены:

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    stop_sequences=["###", "END"],  # остановиться при достижении маркера
    messages=[...]
)

## Слой 7: batch API для несрочных задач

Многие организации отправляют запросы по одному, тогда как пакетная обработка была бы эффективнее.

Batch API Anthropic даёт 50% скидку на входящие токены для асинхронных запросов, которые не требуют немедленного ответа. Подходит для: генерации документации, анализа кодовой базы, создания тест-кейсов, пакетного рефакторинга.

import anthropic

client = anthropic.Anthropic()

# Отправить несколько запросов пакетом
batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "task-1",
            "params": {
                "model": "claude-sonnet-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Задача 1"}]
            }
        },
        {
            "custom_id": "task-2", 
            "params": {
                "model": "claude-sonnet-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Задача 2"}]
            }
        }
    ]
)
# Результаты доступны через несколько минут, входящие токены — -50%

## Слой 8: мониторинг — оптимизировать то, что видишь

Нельзя оптимизировать то, чего не видишь. Производственные AI-команды в 2026 году запускают слой наблюдаемости, который отслеживает потребление токенов на функцию, пользователя, модель с денежной атрибуцией.

### В Claude Code

/usage  # текущее потребление сессии

Вывод показывает разбивку по навыкам, субагентам, плагинам и отдельным MCP-серверам — каждый как процент от общего.

### Для API-приложений

Каждый ответ от API содержит точные данные об использовании:

response = client.messages.create(...)

print(f"Входящие токены: {response.usage.input_tokens}")
print(f"Исходящие токены: {response.usage.output_tokens}")
print(f"Кэш прочитано: {response.usage.cache_read_input_tokens}")
print(f"Кэш записано: {response.usage.cache_creation_input_tokens}")

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

## Типичные ловушки

Ошибка #1: экономить на промпте → платить за переспрашивание. Расплывчатый промпт дешевле, только если Claude угадал правильно. Если нет — вы платите за уточняющие вопросы и переработку.

Ошибка #2: /compact слишком поздно. К моменту когда появляется предупреждение о контексте — сессия уже перегружена и сводка получается грязной. Compact на 50-70% заполнения дёшевле и качественнее.

Ошибка #3: включённые инструменты которые не используются. Каждый подключённый MCP-коннектор стоит токенов на каждом сообщении — независимо от того, используете ли вы его.

Ошибка #4: extended thinking на простых задачах. По умолчанию thinking включён. Для задачи «переименуй переменную» это буквально тысячи лишних токенов.

Ошибка #5: один большой разговор вместо сфокусированных сессий. Branch8 разбивала большие тикеты на короткие «спринты», охватывая только одну функцию за раз. Каждый спринт начинался с компакта существующего контекста и /clear в конце. Это дало 67% снижение стоимости.

## Быстрый чеклист оптимизации

Выбор модели:
☐ Haiku для механических задач (переименование, форматирование, Q&A)
☐ Sonnet 5 для большинства задач кодирования
☐ Opus только для сложной архитектуры и нетривиального анализа
☐ opusplan для задач где нужен Opus для плана и Sonnet для реализации

Уровень effort:
☐ /effort low для простых задач в Claude Code
☐ MAX_THINKING_TOKENS=8000 для ограничения расходов на мышление
☐ Effort high/max только там где это реально важно

Кэширование:
☐ cache_control: ephemeral на системный промпт в API
☐ Статичный контент идёт первым в структуре запроса
☐ Кэш в Claude Code включён по умолчанию — не отключать

Контекст:
☐ CLAUDE.md компактный — только то что нужно всегда
☐ /compact на 50-70% заполнения, не по предупреждению
☐ /clear при переключении между несвязанными задачами
☐ Отключены коннекторы, не нужные в текущей сессии

Архитектура:
☐ Субагенты для задач с шумным выводом (тесты, логи, анализ файлов)
☐ Batch API для несрочных пакетных задач (−50% на input)
☐ max_tokens соответствует реально нужному размеру ответа

Мониторинг:
☐ /usage отслеживается в Claude Code
☐ usage из API-ответов логируется с атрибуцией по задачам

## Итог

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

Не существует одной «серебряной пули». Оптимизация расходов редко достигается одним изменением. Она приходит от комбинации умного выбора модели, эффективного дизайна промптов, управления контекстом, стратегий кэширования и настройки параметров API.

Порядок приоритетов: правильная модель под задачу → уровень effort → кэш промптов → чистый контекст → субагенты → batch для несрочного. Каждый уровень независим, и даже применение первых двух даёт заметный результат уже сегодня.

Актуально для Claude Sonnet 5, Opus 4.8, Haiku 4.5 и Claude Code 2.x. Июль 2026. Цены и параметры обновляются — проверяйте актуальные значения в docs.anthropic.com.