## Руководство по оптимизации расходов

Писать код с Claude Code — это здорово, но если не следить за использованием, счёт может преподнести «сюрприз». Это руководство поможет понять, как формируются расходы и как разумно контролировать затраты без ущерба для эффективности.

## Понимание тарификации по токенам

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

### Что такое токен

Токен — это минимальная единица обработки текста в AI-модели. Можно представить его как «слово» модели:

- **Английский язык**: 1 токен ≈ 4 символа или 0,75 слова
- **Китайский язык**: 1 иероглиф ≈ 1-2 токена (в среднем ~1,5 токена)
- **Код**: имена переменных, ключевые слова и символы занимают разное количество токенов

Справочная таблица приблизительных расчётов:

| Содержимое | Приблизительно символов/строк | Приблизительно токенов |
|------|-------------|-------------|
| Краткое описание требований на естественном языке | 100 символов | ~150 токенов |
| TypeScript-файл на 200 строк | ~5000 символов | ~1500 токенов |
| Типичный диалоговый ввод с контекстом | — | 5 000–20 000 токенов |
| Системный промпт Claude Code | — | ~8 000 токенов |

### Входные и выходные токены

При каждом взаимодействии с Claude расходы складываются из двух частей:

```
Общие расходы = входные токены × цена входа + выходные токены × цена выхода
```

Ключевой момент: **цена выходных токенов обычно в 5 раз выше цены входных**. Для примера, Sonnet 5:

| Тип | Цена (долларов/миллион токенов) | Стоимость 1000 токенов |
|------|----------------------|-----------------|
| Входные | $2.00 | $0.002 |
| Выходные | $10.00 | $0.010 |
| Чтение из кэша | $0.20 | $0.0002 |

Это означает: позволить Claude генерировать объёмный текст дороже, чем предоставить ему много контекста.

### Сколько токенов потребляет типичный диалог

Для Sonnet 5 — примерная стоимость в нескольких распространённых сценариях:

| Сценарий | Входные токены | Выходные токены | Ориентировочная стоимость |
|------|-----------|-----------|---------|
| Простой вопрос (объяснение фрагмента кода) | 3 000 | 500 | $0.017 |
| Изменение одной функции | 8 000 | 1 500 | $0.047 |
| Создание нового компонента (с чтением файлов) | 15 000 | 3 000 | $0.090 |
| Разработка сложной функциональности (много раундов диалога) | 50 000 | 15 000 | $0.375 |
| Масштабный рефакторинг (10+ файлов) | 200 000 | 50 000 | $1.350 |

> Приведённые цифры являются лишь ориентиром; фактические расходы зависят от объёма вашего кода, числа раундов диалога и размера контекста.

## Стратегия выбора модели

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

### Позиционирование трёх моделей

| Модель | Цена входа | Цена выхода | Позиционирование |
|------|---------|---------|------|
| Haiku 4.5 | $1.00 | $5.00 | Лёгкая и быстрая, для простых повседневных задач |
| Sonnet 5 | $2.00 | $10.00 | Лучший баланс, основная рабочая модель |
| Opus 5 | $5.00 | $25.00 | Текущий флагман, по той же цене, что и 4.7 |
| Opus 4.7 | $5.00 | $25.00 | Флагман прошлого поколения, по-прежнему доступен |

**Сравнение расходов**: выполнение одной и той же задачи средней сложности (вход 10K, выход 3K токенов):

- Haiku: $0.025
- Sonnet: $0.050
- Opus: $0.125

Sonnet 5 в 2 раза дороже Haiku, Opus 5 — в 5 раз.

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

```
Повседневный выбор — Sonnet (80% задач решаются им)

Переключайтесь на Opus только в следующих случаях:
  - Сложное архитектурное проектирование и технические решения
  - Масштабный рефакторинг кода
  - Межмодульные изменения, затрагивающие несколько систем
  - Сложные баги, требующие глубокого анализа

Переключайтесь на Haiku только в следующих случаях:
  - Простые преобразования форматов
  - Генерация повторяющегося кода (например, CRUD-интерфейсов)
  - Быстрые вопросы (на которые можно ответить одним предложением)
  - Комментирование кода и создание документации
```

Используйте команду `/model`, чтобы переключаться в любой момент:

```
/model sonnet    # Переключиться на Sonnet
/model opus      # Переключиться на Opus
/model haiku     # Переключиться на Haiku
```

## Техники экономии через управление контекстом

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

### Сжатие истории с помощью /compact

Когда диалог длится более 10 раундов или вы замечаете замедление ответов, используйте `/compact`:

```
/compact
```

`/compact` заставляет Claude свести предыдущий диалог в краткое резюме, заменяющее полную историю. Благодаря этому количество входных токенов в следующем раунде значительно сокращается.

**Когда использовать:**
- Диалог превысил 10 раундов
- Подзадача завершена, и вы готовы перейти к следующей
- Чувствуете, что качество ответов Claude снижается (признак перегрузки контекста)

### Полная очистка с помощью /clear

При переходе на совершенно другую тему смело используйте `/clear`:

```
/clear
```

**Когда использовать:**
- Переход от разработки функции A к функции B
- Отладка завершена, начинается написание нового кода
- Диалог ушёл в сторону, и вы хотите начать заново

> **Цена отказа от /clear**: предположим, что предыдущая история диалога занимает 50K токенов. После смены темы вы в каждом раунде впустую платите за эти 50K токенов. По тарифам Sonnet это дополнительно $0.15 за раунд. За 10 раундов диалога вы потеряете $1.5.

### Точные ссылки через @

Разница в стоимости между тем, когда Claude сам ищет файлы, и тем, когда вы напрямую на них ссылаетесь, очень велика:

```bash
# Дорого! Claude может просмотреть десятки файлов, чтобы найти нужный код
"Помоги изменить часть с проверкой email в логике регистрации пользователя"

# Дёшево! Напрямую укажи Claude, где искать
"Измени регулярное выражение в методе validateEmail файла @src/services/auth-service.ts"
```

Когда вы знаете, какой файл нужно изменить, всегда используйте `@` для прямой ссылки. Позволять Claude искать самостоятельно не только дороже, но и результат может оказаться неточным.

### Исключение больших файлов через .claudeignore

Убедитесь, что следующие типы файлов добавлены в `.claudeignore`:

```bash
# Если эти файлы будут прочитаны Claude, они потребляют огромное количество токенов
node_modules/          # Зачастую десятки тысяч файлов
dist/                  # Результаты сборки
*.min.js               # Минифицированный JS
*.sql                  # Дампы базы данных
*.csv                  # Файлы данных
package-lock.json      # Lock-файл (огромного объёма)
pnpm-lock.yaml         # Lock-файл
yarn.lock              # Lock-файл
```

> **Реальный случай**: один пользователь обнаружил аномально высокие расходы и при разборе выяснил, что Claude при поиске кода прочитал SQL-дамп размером 50 МБ — за один раз было потреблено около 15 млн токенов (около $45 за входные данные).

## Использование механизма кэширования

Prompt Caching — это очень важная функция экономии в Claude API.

### Что такое Prompt Caching

Когда вы ведёте многораундовый диалог, в каждом раунде заново отправляется всё предыдущее содержимое. Без кэширования каждый раз тарификация идёт по полной цене входных токенов. С кэшированием:

- **Первая отправка**: по обычной цене входа (цена записи в кэш немного выше)
- **Последующие отправки**: совпадающее содержимое попадает в кэш и оплачивается по цене чтения из кэша (всего 1/10)

Для примера, Sonnet 5:

| Тип | Цена/миллион токенов | По сравнению с обычным входом |
|------|----------------|------------|
| Обычный вход | $2.00 | 100% |
| Запись в кэш | $2.50 | 125% |
| Чтение из кэша | $0.20 | 10% |

То есть **при попадании в кэш платить нужно лишь 1/10 цены**.

### Как эффективно использовать кэширование

Кэширование работает автоматически, но вы можете повысить долю попаданий в кэш своими привычками работы:

**Сохраняйте связность диалога:**

```bash
# Хорошая привычка: продолжайте разработку одной и той же функции в одном диалоге
> "Создай базовую структуру UserService"
> "Добавь метод getUserById"        # Предыдущее содержимое попадает в кэш
> "Добавь метод updateUser"         # Предыдущее содержимое попадает в кэш
> "Добавь unit-тесты"               # Предыдущее содержимое попадает в кэш

# Плохая привычка: делать /clear после каждой фразы
> "Создай базовую структуру UserService"
> /clear
> "Добавь метод getUserById в UserService"    # Кэш использовать не получится
> /clear
> "Добавь метод updateUser в UserService"     # Кэш использовать не получится
```

**Не изменяйте CLAUDE.md слишком часто:**

Содержимое CLAUDE.md отправляется в каждом раунде диалога. Если оно стабильно, то надолго остаётся в кэше. Частые изменения приводят к промахам кэша.

**Разумное время для /compact:**

`/compact` заменяет историю, из-за чего кэш становится недействительным. Поэтому не используйте его слишком часто — применяйте только тогда, когда диалог действительно стал слишком длинным.

### Насколько велик эффект кэширования

Предположим, что у нас 10-раундовый диалог, и каждый раунд содержит около 20K входных токенов (включая историю):

| | Без кэша | С кэшем (90% попаданий) |
|---|---|---|
| Всего входных токенов | 200K | 200K |
| По обычной цене | 200K | 20K |
| По цене кэша | 0 | 180K |
| Общие входные расходы (Sonnet) | $0.60 | $0.114 |
| **Экономия** | — | **$0.486 (81%)** |

Кэширование может сэкономить около 80% входных расходов.

## Мониторинг и бюджет

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

### /cost — просмотр текущей сессии

В любой момент введите в Claude Code:

```
/cost
```

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

### QCode.cc Dashboard — просмотр истории

Войдите в [консоль QCode.cc](https://qcode.cc/dashboard) — на странице «Статистика использования» вы увидите:

- **Детализацию вызовов по моделям**: использованную модель, количество токенов и стоимость каждого вызова
- **Сводку по дням/месяцам**: графики трендов расходов
- **Прогресс расходования тарифа**: процент использования лимита текущего тарифа

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

### Рекомендации по контролю расходов

| Уровень использования | Рекомендуемая стратегия по моделям | Ориентировочный месячный бюджет |
|---------|-----------|----------|
| Лёгкое использование (1-2 часа в день) | В основном Sonnet | $30-80 |
| Умеренное использование (3-5 часов в день) | Sonnet + изредка Opus | $80-200 |
| Интенсивное использование (разработка весь день) | Sonnet как основа + Opus для архитектурных решений | $200-500 |

## Частые ловушки расходов

Ниже перечислены ситуации, в которых проще всего впустую растратить токены. Сверьтесь с этим списком и проверьте, не попадаетесь ли вы в эти ловушки:

### Ловушка 1: прямое вставление больших файлов

```bash
# Неправильный подход: вставить содержимое файла в диалог
> "Вот мой код, помоги проверить его:
[вставлено 500 строк кода]"

# Правильный подход: использовать ссылку через @
> "Проверь метод createOrder в файле @src/services/order-service.ts"
```

Разница: вставка 500 строк кода составляет около 1500 входных токенов, и это содержимое повторно отправляется в каждом раунде диалога. При использовании `@` для ссылки на тот же файл Claude читает его только при необходимости, а прочитанное содержимое к тому же кэшируется.

### Ловушка 2: постоянные повторные попытки одной и той же неудачной команды

```bash
# Неправильный подход: раз за разом заставлять Claude выполнять одну и ту же неудачную команду
> "Запусти npm run build"
# Не удалось
> "Попробуй ещё раз"
# Снова не удалось
> "Ещё разок"

# Правильный подход: проанализировать причину сбоя и сменить подход
> "Запусти npm run build"
# Не удалось
> "Посмотри логи ошибок, проанализируй причину сбоя, исправь проблему и собери заново"
```

Каждая повторная попытка отправляет полную историю диалога (включая все предыдущие неудачные выводы), и расход токенов быстро накапливается.

### Ловушка 3: забыть про /clear и получить разбухание контекста

Это самая незаметная ловушка расходов:

```bash
# Утром: исправили баг (диалог накопил историю на 30K токенов)
# После обеда: начали писать новую функцию, но не сделали /clear
# Каждый новый раунд диалога впустую тащит с собой утренние 30K токенов истории

# Решение: выработайте привычку делать /clear при смене задачи
/clear
> "Теперь начинаем разработку новой функции..."
```

### Ловушка 4: использование Opus для простых задач

```bash
# Расточительно: использовать Opus для генерации простого интерфейса
/model opus
> "Помоги определить интерфейс User с полями id, name, email"

# Экономно: для простых задач достаточно Haiku
/model haiku
> "Помоги определить интерфейс User с полями id, name, email"
```

В этой задаче результат обеих моделей практически одинаков, но Opus стоит в 5 раз дороже Haiku.

### Ловушка 5: позволить Claude искать по всему проекту

```bash
# Дорого: Claude может прочитать десятки файлов
> "Найди в проекте код, обрабатывающий платежи"

# Дёшево: подскажи ему примерное расположение
> "Найди сервис обработки платежей в каталоге @src/services/"

# Самый дешёвый вариант: напрямую указать файл
> "Посмотри @src/services/payment-service.ts"
```

## Чек-лист оптимизации расходов

Каждый раз при использовании Claude Code сверяйтесь с этим списком:

- [ ] Выбрана ли подходящая модель (для большинства задач — Sonnet)
- [ ] Используете ли вы ссылку через `@` вместо вставки содержимого файлов
- [ ] Выполняете ли `/clear` при смене темы
- [ ] Рассматриваете ли `/compact`, если диалог превысил 10 раундов
- [ ] Настроен ли `.claudeignore` для исключения больших файлов
- [ ] Достаточно ли чётко сформулированы требования (чтобы избежать переделок из-за недопонимания)
- [ ] Проверили ли вы `/cost`, чтобы понять текущее потребление

Выработав эти привычки, вы обнаружите, что расходы можно снизить на 30-50%, при этом эффективность разработки нисколько не пострадает.

## Prompt-кэширование и стоимость

Ранее уже упоминалось, что попадание в кэш стоит лишь 1/10 цены входных токенов. В этом разделе подробнее объясняется *почему* так и как самостоятельно проектировать контекст, чтобы максимизировать выгоду от кэша.

### Кэшируется только стабильный префикс

Prompt Caching в Claude API кэширует **стабильный префикс вашего промпта** — неизменное начало: системный промпт, CLAUDE.md, объёмные справочные материалы и т. п. После попадания в кэш чтение этой части стоит около 10% от обычного входа (примерно на 90% дешевле). Главное здесь в том, что кэш работает по принципу «префикса»: как только что-то в начале префикса меняется, весь кэш от точки изменения и далее становится недействительным.

Поэтому ключевой принцип экономии таков: **размещайте неизменное содержимое в самом начале и старайтесь его не редактировать**.

| Тип содержимого | Размещение | Дружелюбность к кэшу |
|---------|---------|-----------|
| Системный промпт, CLAUDE.md | В самом начале (стабильно) | Высокая, долгие попадания |
| Соглашения проекта, документация API и прочий длинный контекст | Ближе к началу (стабильно) | Высокая |
| Конкретные инструкции для текущей задачи | Ближе к концу | Низкая (по природе часто меняются) |
| Живая история диалога | В конце | Растёт вместе с диалогом |

### Как сделать контекст дружелюбным к кэшу

- **Лаконичный и стабильный CLAUDE.md**: содержимое с высокой плотностью смысла и редкими правками. Частые изменения CLAUDE.md обнуляют весь кэш, идущий после него, заставляя каждый раз пересчитывать всё по полной цене.
- **Переиспользуйте сессии**: продолжайте вести одну и ту же задачу в рамках одной сессии — тогда префикс остаётся неизменным, и каждый последующий раунд оплачивается по цене чтения из кэша.
- **Ссылайтесь по пути вместо вставки**: используйте `@путь` для ссылки на файлы, а не вставляйте содержимое в диалог — это и сокращает количество токенов, и не даёт изменчивому содержимому попасть в префикс и сломать кэш.
- **Используйте /compact осторожно**: `/compact` переписывает резюме истории, что фактически переписывает префикс и обнуляет существующий кэш, — применяйте его только когда диалог действительно стал слишком длинным.

> Если коротко: стабильное содержимое — в начало, изменчивое — в конец, и не редактируйте префикс без нужды — вот ключ к тому, чтобы получить скидку кэша при минимальных затратах. Об иерархии контекста и приёмах его сокращения см. сопутствующие рекомендации в [Руководстве по выбору модели](/docs/usage/model-selection).

## Выбор модели по роли

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

### Распределение по ролям

| Роль задачи | Рекомендуемая модель | Типичные сценарии |
|---------|---------|---------|
| Поиск / форматирование / простое переписывание | Haiku 4.5 | Поиск в документации, преобразование форматов, правка комментариев, вопросы с ответом в одно предложение |
| Повседневная реализация / исправление багов | Sonnet 5 | Написание функций, изменение логики, обычная отладка (около 80% работы). 4.6 всё ещё в продаже |
| Архитектура / крупный рефакторинг / оркестрация | Opus 5 | Межмодульное проектирование, масштабный рефакторинг, оркестрация многошаговых задач, сложные рассуждения. 4.8 всё ещё в продаже |
| Кодинг в стиле Codex | gpt-5.6-terra | Генерация кода в рабочих процессах в стиле Codex |

Основная идея — **не запускать Opus на тривиальных задачах**: для простого определения интерфейса Haiku и Opus дают почти одинаковый результат, но Opus в 5 раз дороже. Приберегите тяжёлую модель для этапов, которые действительно требуют глубоких рассуждений.

### Переключение в середине сессии

Команда `/model` позволяет переключаться в любой момент, без перезапуска сессии:

```
/model haiku     # Перейти на лёгкую модель для простых шагов
/model sonnet    # Вернуться к основной модели и продолжить реализацию
/model opus      # Временно повысить уровень при архитектурном решении
```

Эффективный ритм экономии таков: вести основную часть разработки на Sonnet, при архитектурном затруднении временно переключаться командой `/model opus` для обдумывания, а после принятия решения возвращаться к Sonnet; объёмную же простую доработку поручать Haiku. Подробное сравнение возможностей по моделям и советы по выбору см. в [Руководстве по выбору модели](/docs/usage/model-selection).