Token Optimization

Как снизить расход токенов в Claude Code на 75%

2026-09-02·14 мин мин чтения·LLMPodium Team

### Краткий ответ: как заставить Claude тратить меньше токенов

Чтобы снизить расход токенов в Claude Code на величину до 75%, внедрите четыре ключевые оптимизации: настройте строгий .claudeignore для отсечения артефактов сборки и lock-файлов; используйте 90% скидку на чтение prompt caching от Anthropic со статичными промптами; изолируйте подзадачи с помощью поисковых subagents для защиты от context rot; выбирайте claude-3-7-sonnet с компактным выводом или claude-3-5-haiku для рутинного анализа AST до перехода на Opus.

1. Введение: скрытая утечка бюджета токенов в терминале

Автономные терминальные агенты, такие как Claude Code от Anthropic, произвели революцию в процессах разработки программного обеспечения. В отличие от стандартных автодополнений в IDE, Claude Code функционирует в рамках автономного цикла: инспектирует структуру каталогов, читает файлы объемом в тысячи строк, выполняет команды оболочки, анализирует логи компилятора и точечно вносит изменения в код.

Однако эта автономность имеет высокую экономическую цену. Без предварительной грамотной настройки невинный запрос вида «Проведи рефакторинг middleware авторизации для поддержки ротации JWT» может сжечь от 1,5M до 3,5M токенов за одну рабочую сессию. Подобная инфляция токенов обусловлена несколькими ключевыми факторами:

  1. Накопление контекста (Context Rot): Каждый вывод bash-команды, результаты grep, дампы компилятора и прочитанные целиком файлы остаются внутри активного контекстного окна агента.
  2. Повторное считывание без кэша: Случайная модификация ранних реплик в диалоге разрушает 5-минутный интервал эфемерного кэширования промптов (prompt caching) от Anthropic.
  3. Загрузка избыточных артефактов: Claude Code раз за разом считывает сгенерированные файлы сборки (dist/, target/, .next/), многомегабайтные lock-файлы (package-lock.json, pnpm-lock.yaml) и дампы БД при глобальном поиске через regex.
  4. Избыточная мощность модели (Overspecification): Использование флагманских моделей глубокого мышления (claude-3-opus или Sonnet с максимальным thinking) для банального поиска файлов или навигации по папкам.

Применяя системные архитектурные ограничения — дисциплину .claudeignore, механизмы prompt caching, изоляцию контекста через субагенты и точные настройки CLI, — инженерные команды стабильно сокращают ежедневное потребление токенов в Claude Code на 70–80%, попутно повышая процент успешного выполнения задач.

2. Экономика токенов: архитектура ценообразования и кэширования

Чтобы понять, куда утекают токены, рассмотрим тарифную сетку Anthropic API с учетом уровней кэширования (базовые тарифы 2026 года):

Модель Claude Базовый Input ($/1M) Запись в кэш ($/1M) Чтение из кэша ($/1M) Output ($/1M) SWE-bench Verified Оптимальная роль в терминале
Claude 3.5 / 3.7 Haiku $0.80 $1.00 $0.08 $4.00 41.2% Поиск символов, фильтрация через regex, коммит-сообщения
Claude 3.7 Sonnet (Standard) $3.00 $3.75 $0.30 $15.00 70.3% Основной рефакторинг, правки нескольких файлов, тесты
Claude 3.7 Sonnet (Extended Thinking) $3.00 (in) $3.75 (write) $0.30 $15.00 (thought + out) 72.8% Сложные архитектурные баги, состояния гонки (concurrency)
Claude 3 Opus / Opus 4.6 $15.00 $18.75 $1.50 $75.00 74.1% Критичные аудиты безопасности, глобальный редизайн системы

Математика сокращения затрат и токенов на 75%

Рассмотрим типичную сессию Claude Code из 15 итераций по рефакторингу эндпоинта REST API в репозитории TypeScript на 150 000 строк кода: 

[Неоптимизированная сессия]
Итерация 1: Загрузка карты репозитория + package-lock.json + схемы (180 000 токенов)
Итерации 2-5: Дампы grep, логи сборки, чтение файлов целиком (кумулятивно 240 000 токенов/шаг)
Процент промахов кэша: 45% (частая инвалидация из-за динамических заголовков/инструментов)
Всего обработано входных токенов: 3 250 000
Реальная стоимость (Sonnet): ~$9.75

[Оптимизированная сессия: .claudeignore + Prompt Cache + Subagents]
Итерация 1: Компактная сводка AST (18 000 токенов) -> закэшировано на 1-м шаге
Итерации 2-5: Инкрементальные диффы, субагент-скаут возвращает сжатый отчет (22 000 токенов/шаг)
Процент попадания в кэш: 92% (чтение из кэша по тарифу $0.30/1M)
Всего обработано входных токенов: 410 000 (физическое снижение токенов на 87.3%)
Реальная стоимость (Sonnet): ~$0.82 (снижение затрат на 91.5%)

3. Столп 1: Настройка .claudeignore для исключения мусорного контекста

Самое эффективное действие с точки зрения экономии токенов в любом репозитории — создание строгого, продуманного файла .claudeignore.

По умолчанию Claude Code учитывает стандартные правила .gitignore, однако обычный .gitignore пропускает массу тяжелых файлов, которые засоряют контекстное окно нейросети. Lock-файлы зависимостей, документация, результаты сборки и минифицированные бандлы никогда не должны попадать в контекст агента.

Готовый шаблон .claudeignore для production

Разместите этот файл в корне вашего проекта: 

# ==============================================================================
# .claudeignore - Матрица отсечения нецелевых токенов
# Блокирует загрузку мусорных артефактов при операциях glob и grep в Claude Code
# ==============================================================================

# Lock-файлы пакетов (Огромные JSON/YAML дампы с нулевой ценностью для AST)
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb
composer.lock
Gemfile.lock
Cargo.lock
poetry.lock

# Артефакты сборки и скомпилированные бандлы
dist/
build/
out/
.next/
.nuxt/
.astro/
.svelte-kit/
storybook-static/
target/
*.min.js
*.min.css
*.map

# Отчеты о покрытии тестами, логи и профилирование
coverage/
.nyc_output/
*.lcov
*.log
npm-debug.log*
yarn-debug.log*
pnpm-debug.log*
*.heapsnapshot
*.cpuprofile

# Медиа-файлы, статика и бинарные блобы
public/assets/
public/images/
*.png
*.jpg
*.jpeg
*.gif
*.svg
*.webp
*.avif
*.ico
*.pdf
*.zip
*.tar.gz
*.wasm

# Документация и внешние спецификации API
docs/
*.mdx
specs/swagger/
*.postman_collection.json

# Локальные переменные окружения и сертификаты
.env*
!.env.example
*.pem
*.key
*.cert

# Миграции баз данных и дампы
*.sql
*.dump
prisma/migrations/

Практический эффект от .claudeignore

Когда Claude Code выполняет рекурсивное сканирование или поиск символов, незаблокированный package-lock.json (зачастую от 25 000 до 80 000 строк) может мгновенно сжечь более 120 000 токенов за одно чтение. Добавление lock-файлов и скомпилированного кода в черный список уменьшает первоначальный слепок контекста со 180k токенов до менее чем 15k токенов.

4. Столп 2: Архитектура Prompt Caching и выгода от 90% скидки

Механизм кэширования промптов от Anthropic сохраняет входящие токены в кэше на срок до 5 минут (таймер обновляется при каждом новом попадании). Чтение закэшированного контекста стоит всего 10% от базовой стоимости входа ($0.30/1M против $3.00/1M на Sonnet). 

+-------------------------------------------------------------------------+
|                  Жизненный цикл Prompt Caching в Anthropic              |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
| [Системный промпт и системные инструменты] (Статичный префикс - кэш)    |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
| [Архитектурная карта проекта и гайдлайны] (Закэшированная контрольная т.)|
+-------------------------------------------------------------------------+
                                     |
                                     v (Точка разрыва кэша!)
+-------------------------------------------------------------------------+
| [Динамические запросы пользователя и вызовы tool] (Незакэшированный хвост)|
+-------------------------------------------------------------------------+

Правила сохранения целостности кэша промптов

  1. Никогда не внедряйте динамические таймстемпы в системный контекст: Избегайте добавления текущей даты или динамических session ID в CLAUDE.md. Изменение хотя бы одного символа в начале префикса инвалидирует все последующие закэшированные токены.
  2. Группируйте запросы в пределах 5-минутного окна: Время жизни (TTL) кэша составляет 300 секунд. Если вы отвлеклись на 6 минут на ревью кода, следующий запрос повлечет полную оплату записи в кэш ($3.75/1M). Проводите интерактивные сессии динамично либо заранее формулируйте цепочки задач.
  3. Упорядочивайте инструкции от максимально статичных к динамичным: Внутренний движок Claude Code помещает системные инструкции в начало полезной нагрузки API. Следите за тем, чтобы инструкции в файле CLAUDE.md оставались детерминированными.

5. Столп 3: Запуск субагентов и изоляция контекста подзадач

Одна из главных архитектурных ловушек при работе с терминальными агентами — ловушка монолитной сессии. В рамках одной сессии разработчик часто просит Claude исследовать баг, написать тесты, провести рефакторинг, запустить сквозное тестирование и оформить документацию.

К 12-му шагу контекстное окно переполняется сотнями строк логов упавших тестов, ошибками сборки и устаревшими версиями файлов. Каждый следующий запрос повторно отправляет весь этот раздутый контекст в API.

Двухуровневая архитектура агентов: Скаут и Исполнитель

Чтобы предотвратить раздувание контекста, отделите исследовательскую фазу от непосредственного изменения кода: 

[Запрос пользователя]
       |
       v
+---------------------------------------------+
|  Уровень 1: Скаут-субагент (Read-Only)      |
|  - Работает на claude-3-5-haiku / легкой LLM|
|  - Использует glob, grep и чтение диапазонов|
|  - Сжимает 500 000 токенов в отчет на 2 КБ  |
+---------------------------------------------+
       |
       v (Передача сжатого контекста)
+---------------------------------------------+
|  Уровень 2: Основной рабочий агент          |
|  - Работает на claude-3-7-sonnet            |
|  - Получает ТОЧНЫЕ пути к файлам и символы  |
|  - Применяет точечные патчи с привязкой строк|
+---------------------------------------------+

Реализация изоляции подзадач в Claude Code

При решении комплексных задач разделяйте рабочий процесс на независимые сессии терминала или используйте изолированное делегирование: 

# Плохо: монолитное раздувание контекста
claude "Найди все эндпоинты с устаревшей авторизацией, переведи их на OAuth2, почини тесты и обнови документацию"

# Хорошо: изолированное исследование -> точечное исполнение
# Шаг 1: Разведка с минимальным расходом токенов
claude --model claude-3-5-haiku -p "Выведи только пути к файлам и номера строк с устаревшим auth middleware. Верни в виде JSON-списка." > auth-audit.json

# Шаг 2: Точечная модификация в чистом контексте
claude --model claude-3-7-sonnet "Проведи рефакторинг эндпоинтов из auth-audit.json на OAuth2 middleware. Не изменяй другие файлы."

Благодаря разделению этапов разведки и исполнения основная модель reasoning не тратит контекст на чтение тысяч строк нерелевантного кода.

6. Столп 4: Выбор модели — какая модель Claude тратит меньше токенов?

Распространенное заблуждение разработчиков заключается в том, что все модели семейства Claude расходуют одинаковое число токенов на решение одной и той же задачи. На практике потребление токенов сильно различается в зависимости от:

  • Бюджета на рассуждения (Thinking Budget): Модели с режимом extended thinking генерируют тысячи внутренних токенов размышлений, которые тарифицируются как выходные токены ($15.00/1M на Sonnet).
  • Многословности вызова инструментов (Tool Call Verbosity): Некоторые модели выдают развернутые текстовые преамбулы перед вызовом инструментов, раздувая генерацию.
  • Эффективности поиска: Продвинутые модели находят нужные символы в кодовой базе за 1-2 точных вызова grep, тогда как более простые модели могут без разбора читать файлы целиком.

Сравнение расхода токенов по типам задач

Тип задачи Claude 3.5 Haiku Claude 3.7 Sonnet (Normal) Claude 3.7 Sonnet (Thinking: 8k) Claude 3 Opus
Поиск символа в репозитории 12k токенов / $0.01 14k токенов / $0.04 24k токенов / $0.18 18k токенов / $0.27
Исправление бага в функции 28k токенов / $0.03 22k токенов / $0.07 35k токенов / $0.24 30k токенов / $0.45
Рефакторинг (5 файлов) Высокий % ошибок 140k токенов / $0.48 190k токенов / $1.25 220k токенов / $3.30
Сложное состояние гонки Не решает 320k токенов (неудача) 240k токенов (решено) / $1.60 280k токенов / $4.20

Практические рекомендации

  • Основная рабочая лошадка: Используйте claude-3-7-sonnet без extended thinking для 80% повседневных инженерных задач.
  • Разведка и вспомогательные скрипты: Применяйте claude-3-5-haiku для сканирования репозитория, генерации regex, базовых bash-скриптов и сортировки логов тестов.
  • Режим глубокого мышления: Включайте extended thinking (thinking: { budget_tokens: 4000 }) исключительно для сложных алгоритмических аномалий или ошибок компилятора, которые не удалось устранить с первой попытки.

7. Тонкая настройка конфигурации Claude Code

Claude Code поддерживает гибкое конфигурирование параметров. Вы можете задать глобальные пользовательские настройки в ~/.claude.json или правила для конкретного проекта в .claude/config.json.

Конфигурация высокой эффективности .claude/config.json

{
  "$schema": "https://json.schemastore.org/claude-code-config.json",
  "model": "claude-3-7-sonnet",
  "maxThinkingTokens": 2048,
  "autoCompactContext": true,
  "contextCompactionThreshold": 0.65,
  "allowedTools": [
    "Edit",
    "Bash",
    "Glob",
    "Grep",
    "Read"
  ],
  "toolLimits": {
    "bashOutputMaxLines": 150,
    "readFileMaxLines": 300
  },
  "enableTelemetry": false
}

Разбор ключевых параметров

  1. maxThinkingTokens: 2048: Ограничивает объем генерации мыслей в режиме reasoning. По умолчанию неконтролируемые рассуждения могут съедать от 8k до 16k токенов ($0.12 - $0.24) за один шаг на относительно простых задачах.
  2. autoCompactContext: true: Включает автоматическое сжатие истории диалога при заполнении контекстного окна на 65% (contextCompactionThreshold: 0.65). Система заменяет старые вызовы инструментов и выводы bash краткой выжимкой, освобождая ресурсы.
  3. bashOutputMaxLines: 150: Предотвращает ситуации, когда прогон тестовых наборов или установка пакетов сбрасывает 5000 строк логов прямо в контекст LLM.

8. Тактические приемы составления промптов в терминале

Привычки формулирования запросов определяют до 40% общего расхода токенов за сессию. Используйте проверенные шаблоны:

Прием 1: Чтение конкретных диапазонов строк

Вместо команды на чтение файла целиком, явно ограничивайте анализируемые строки: 

# Плохо: читает 1800 строк (14 000 токенов)
"Прочитай src/auth/session.ts и найди, почему падает проверка пользовательского токена"

# Хорошо: читает только 60 строк (450 токенов)
"Посмотри строки 120-180 в файле src/auth/session.ts, где объявлена функция verifyJwt()"

Прием 2: Фильтрация вывода терминала

При запуске тестов или сборки проекта всегда требуйте лаконичного или отфильтрованного вывода: 

# Плохо: выгружает в контекст тысячи строк успешных тестов
"Запусти npm test и исправь ошибки"

# Хорошо: подавляет шум
"Запусти npm test -- --reporter=dot или отфильтруй ошибки через grep. Не выводи логи успешных тестов."

Прием 3: Явная очистка и сжатие (/compact и /clear)

Активно используйте встроенные команды Claude Code:

  • /compact: Принудительно запускает немедленное сжатие текущего контекста, заменяя историю компактным техническим саммари.
  • /clear: Полностью очищает контекст перед началом следующей несвязанной задачи без перезапуска сессии терминала.

9. Сравнительная матрица: стратегии сокращения расхода токенов

В таблице ниже приведен сравнительный анализ методов оптимизации по объему экономии, сложности внедрения и риску деградации качества кода:

Стратегия оптимизации Средняя экономия токенов Сложность внедрения Риск для качества кода Основной механизм действия
Строгий .claudeignore 40% – 60% Низкая (5 минут) Нулевой Блокирует lock-файлы, медиа и директории сборки
Сжатие контекста (/compact) 30% – 50% Мгновенно (команда) Низкий Удаляет устаревшие bash-выводы и старые версии файлов
Разведка через субагентов 35% – 55% Средняя Минимальный Разделяет тяжелое чтение и дорогое редактирование
Лимит бюджета thinking 20% – 35% Низкая (правка конфига) Низкий-средний Предотвращает бесконечные циклы размышлений
Точечные патчи строк 15% – 25% Низкая (шаблон запроса) Низкий Заменяет переписывание файлов компактными diff-правками
Выравнивание prompt cache 10% – 20% (затраты) Средняя Нулевой Реализует 90% скидку за счет фиксации префиксов

10. Заключение и чек-лист внедрения

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

Чек-лист из 5 шагов:

  1. [ ] Внедрите .claudeignore: разместите готовый production-шаблон в корне репозитория. Заблокируйте все lock-файлы и папки сборки.
  2. [ ] Скорректируйте config.json: ограничьте thinking-токены лимитом 2048 и включите autoCompactContext на уровне 0.65.
  3. [ ] Подбирайте модели под задачу: держите claude-3-7-sonnet для правок, claude-3-5-haiku для поиска и берегите extended thinking для сложных алгоритмических багов.
  4. [ ] Контролируйте вывод консоли: используйте минималистичные флаги тест-раннеров (--reporter=min, фильтрацию через head/grep), чтобы удерживать вывод bash в пределах 100 строк.
  5. [ ] Регулярно очищайте контекст: вызывайте /compact или /clear между логическими этапами разработки, защищаясь от context rot.

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

← Все статьи
0 / 4
Сравнить →