Токены в ИИ: как устроены и как экономить

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

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

Не понимаешь механику — сжигаешь $130 за сутки на обычных задачах: рефакторинг, коммиты, объяснение чужого кода и один большой JSON-файл, который модель перечитала несколько раз.

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

Я впервые задумался, что трачу слишком много токенов, в тот день, когда посмотрел в ccusage. Это консольная утилита, которая показывает расход токенов в Claude Code по дням, сессиям и моделям с оценкой в долларах.

Там было $130 за сутки.

Задачи были обычные. Рефакторинг пары модулей, коммиты, объяснения чужого кода. Я открыл разбивку по проектам, прошёлся по сессиям — и нашёл корень.

Один большой JSON-файл.

Я несколько раз кидал его в контекст целиком. Модель прочитала его 5 раз за 2 дня, и каждое чтение стоило мне денег. Вот так тупая привычка превращается в нормальный такой счёт.

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

И поменял 12 вещей. Одни за 5 минут. Другие за неделю.

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

Большую часть примеров я разбираю на Claude Code — сам им пользуюсь. Но статья не про Claude. Токены, контекст, tokenization и context rot — общая механика всех современных LLM. Где есть различия между Claude и GPT — отмечаю отдельно.

Введение

Минимальный словарь для старта

— Turn — один цикл: твой запрос → ответ модели. В одном чате может быть 50 turn’ов. Каждый turn модель снова читает весь контекст, и каждый стоит денег.

— Системный промпт — инструкции для модели, которые грузятся в каждый turn автоматически. В Claude Code это CLAUDE.md и AGENTS.md, в Cursor — .cursorrules, в GPT-5 через API — поле system в запросе. Один раз написал — действует на весь чат.

— Контекст — всё, что модель видит в момент ответа. Системный промпт, история чата, результаты прочитанных файлов и команд.

Что такое токен и зачем это знать

Когда ты пишешь что-то в чат, модель не читает текст побуквенно. Она работает с числами.

Специальная программа-токенайзер режет текст на куски и превращает каждый кусок в числовой идентификатор. Эти куски и называются токенами.

Грубое правило такое. Английское слово — примерно 1 токен. Русское слово — 2–5 токенов. Usage — 1 токен. Использование — 4.

Дело в токенайзере. Это BPE, Byte-Pair Encoding — алгоритм, который учится резать текст на куски на основе частот в обучающих данных. Все популярные модели обучались преимущественно на английском тексте и коде. В Llama-2, например, 89,7% обучающих данных — английский и 8,38% — код. На все остальные языки мира вместе взятые остаётся 2%.

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

Отсюда первое правило, до которого дойдём: системный промпт на русском дороже английского в полтора-два раза.

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

Токены делятся на 2 типа, и разница в цене там пятикратная.

Входные токены — всё, что модель читает перед ответом. Системный промпт, история чата, содержимое открытых файлов, результаты запущенных команд, описание подключённых инструментов.

Выходные токены — то, что модель пишет в ответ.

Цены Claude Sonnet: входные — $3 за миллион, выходные — $15 за миллион. У Opus пропорция та же: $5 и $25. У Haiku: $0.80 и $4. Везде output в 5 раз дороже input.

Чтение — дешёвая операция. Модель пропускает входной текст через свои слои 1 раз и получает представление. Генерация — дорогая. Каждый выходной токен модель вычисляет отдельно, учитывая всё, что уже сгенерировала. Это последовательная операция, её сложно распараллелить.

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

Контекстное окно

Контекстное окно — это всё, что модель держит в памяти одновременно при одном запросе. У Claude 4.6 — до 1 миллиона токенов. У GPT-5 и Gemini — тоже около 1 миллиона.

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

— Системный промпт. CLAUDE.md, AGENTS.md, все подключаемые модули. Это база, которая не меняется. — История текущего чата. Все твои сообщения и все ответы модели. Растёт со временем. — Результаты инструментов. Всё, что модель прочитала из файлов, все выводы команд, все результаты поиска. Накапливается. — Содержимое проекта. Если ты работаешь в агенте с доступом к файловой системе — код, текстовые файлы, README проходят через контекст, когда модель их читает. — Описание подключённых MCP-серверов и их инструментов. Notion, Confluence, GitHub, scheduled-tasks — каждый сервер добавляет описание своих команд в системный промпт.

Активная разработческая сессия на Claude Code сжигает 50 000–100 000 токенов в час. Для ориентира: это примерно 80–160 страниц обычного текста, которые модель перечитывает каждый turn.

Длинная сессия с большими файлами и кучей MCP — сильно больше.

Context rot: почему длинный чат хуже короткого

Есть исследование Chroma. Они прогнали 18 фронтирных моделей на длинных контекстах. Результат: все без исключения деградируют с ростом входа. Даже если контекст далеко не переполнен, каждая следующая тысяча токенов немного ухудшает качество ответов.

Причина в архитектуре transformer: упрощённо, каждый токен сравнивается с каждым другим. Это квадратичная сложность. На 10 000 токенах модель делает 100 миллионов сравнений. На 100 000 — 10 миллиардов.

Сигнал не становится сильнее с ростом контекста. А шум — да. Softmax, который распределяет внимание модели, размазывает его всё тоньше.

Плюс есть эффект lost in the middle. Модель хорошо помнит, что было в начале контекста и что в конце. А то, что в середине длинного контекста, помнит значительно хуже. Точность падает на 30% и больше по данным Stanford.

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

И платишь ты в этот момент дважды: за длинный контекст и за результат хуже. Дисциплина сессий — это про качество не меньше, чем про деньги.

12 способов тратить меньше при том же объёме работы

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

1. RAG вместо полного документа в контексте

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

Если у тебя большая база знаний — корпоративная документация, база по продукту, конкурентный анализ, регламенты — и ты кидаешь весь файл в контекст каждый раз, ты платишь за 200 000 токенов, из которых реально релевантны 5–10 тысяч.

RAG, Retrieval-Augmented Generation, решает это архитектурно.

Вместо схемы «весь файл в контекст» появляется другая: embeddings и vector database. Документы заранее режутся на чанки по 500–1000 токенов. Каждый чанк превращается в числовой вектор через отдельную модель эмбеддингов. При запросе вопрос тоже превращается в вектор, и база находит 5–20 ближайших по смыслу чанков. В контекст летят только они.

Поиск идёт не по ключевым словам, а по семантике. Вопрос «сколько платит команда за облако» найдёт чанк со словами «AWS спенд за квартал», даже если ни одно слово из запроса там не встречается.

Инструменты: pgvector, если уже используешь Postgres; Chroma, если хочешь проще стартовать локально; Pinecone, если нужен облачный вариант. Backend обычно делают на FastAPI или Next.js API routes с pipeline для ингестии новых документов.

Теперь честно про сложность.

RAG — это полноценное отдельное приложение. Нужен backend, vector DB, pipeline ингестии, интерфейс для запросов, процесс обновления базы. Это не настройка за вечер.

Поэтому вывод жёсткий: если ты не делаешь продукт, где LLM должна искать по большой базе, RAG тебе не нужен. Не «не нужен прямо сейчас», а просто не нужен. Для разовой работы с документом есть пункты ниже.

Средний путь для разовой работы с одним большим файлом: открываешь чат, прикладываешь документ, задаёшь все вопросы по нему в одной сессии — и закрываешь чат. Файл при этом кешируется (см. пункт 4 про prompt caching), и повторные вопросы в течение 5 минут стоят в 10 раз дешевле.

Это RAG для одного файла на один вечер, без vector DB и инфраструктуры. Закончил работу — /clear или новый чат, и документа больше нигде нет.

2. Выбор модели под задачу

Самый быстрый способ срезать расходы, до 20 раз: выбирать модель под задачу. Не меняешь процесс, не ставишь инструменты, просто перестаёшь бить по гвоздям микроскопом.

У Claude 3 модели с разницей в цене до 6 раз на входных токенах и до 6 раз на выходных:

— Haiku — для поиска, explore-агентов, bash-команд, простых саммари, классификации. $0.80 за миллион входных токенов. — Sonnet — большинство задач. Коммиты, PR, рефакторинг, объяснения, планирование. Справляется с большинством задач, где раньше автоматически шёл Opus. $3 за миллион входных. — Opus — архитектурные решения, глубокий code review, сложный дебаг с длинным контекстом. $5 за миллион.

По моему ощущению, Sonnet покрывает процентов 90 моих задач. На Opus я переключаюсь в 2 сценариях: архитектурные решения и code review на большом контексте.

У OpenAI логика та же, только названия другие. GPT-5 mini для простого, GPT-5 для большинства, GPT-5 Pro для сложного. Gemini — Flash/Pro/Ultra.

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

Почему это критично для тех, кто работает через API? Если у тебя подписка Claude Pro или Max — ты платишь фиксированную сумму и упираешься в rate limits. Там выбор модели влияет на то, как быстро ты упрёшься в лимит, а не напрямую в деньги. Если работаешь через API — каждый запрос стоит реальных денег, и неправильный выбор модели на больших объёмах превращается в сотни долларов в месяц впустую.

Как настроить. Добавь в ~/.claude/settings.json глобальный дефолт:

{ "model": "claude-sonnet-4-6" }

Переключать прямо в чате: /model haiku для поиска, /model opus для архитектуры.

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

Для этого подойдёт Haiku

Выглядит как мелочь, но на первое время дисциплинирует. Ты начинаешь автоматически думать, какая тут нужна модель, и перестаёшь сидеть на Opus из инерции.

3. Дисциплина сессий и мультиагентная работа

Это самый важный пункт после выбора модели. Экономия тут не в процентах — системная: вся работа идёт чище.

Помнишь про context rot? Длинный чат на 80 000 токенов дорогой и при этом плохо работает: модель путается в деталях, теряет нить, начинает галлюцинировать факты из середины разговора.

Правило простое: задача закончена — открывай новый чат для следующей несвязанной задачи. Не тащи за собой балласт.

Как это устроено под капотом.

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

/compact работает иначе. Она просит модель сделать саммари всей истории и подменяет историю этим саммари. Полезно, когда ты в середине задачи и терять нить нельзя. Но саммари — тоже контекст, и он всё равно растёт.

У меня /clear почти всегда, /compact — редко, когда нельзя терять нить посреди задачи.

Как я веду большую фичу

Сразу оговорюсь: это не процесс на каждую правку опечатки. Это процесс для больших фич, где задача делится на 5–7 шагов и каждый шаг тянет за собой решения.

Для «поправь типо в README» достаточно короткого чата на Haiku. Но когда работа идёт больше часа, разница становится огромной.

Допустим, у тебя проект и нужно накатить новую фичу.

Шаг 1 — Brainstorm. Открываешь новый чат, подключаешь Opus. Берёшь скилл вроде product-brainstorming и прогоняешь задачу: что надо сделать, кому это надо, какие есть варианты реализации, где риски. Opus тут нужен, потому что он сильнее в исследовательских задачах и может предложить неочевидные решения.

Шаг 2 — Спецификация. Новый чат, переключаешься на Sonnet. Скармливаешь результаты brainstorm, просишь написать spec. Sonnet хорошо справляется со структурированной работой по готовой базе.

Шаг 3 — План. Новый чат, Haiku. Просишь разбить spec на конкретные задачи с acceptance criteria. Это простая механическая работа, Haiku её делает быстро и дёшево.

Шаг 4 — Реализация. Теперь у тебя в плане 5–7 задач. Два варианта.

Вариант последовательный. Для каждой задачи — новый чат. Выбираешь модель под сложность: простая CRUD-ручка — Haiku. Новый сервис с логикой — Sonnet. Реструктуризация — Opus. Сделал, закоммитил, запушил, следующая задача — снова новый чат.

Вариант параллельный. Если работаешь с мультиагентами — например, через Superpowers или просто через Task-инструмент Claude Code — можно запустить все 7 задач одновременно, каждую изолированным агентом со своей моделью. Они идут в фоне, не мешают друг другу, не отравляют контексты друг друга. Собираешь результаты по готовности.

Что это даёт. Контекст каждого чата чистый и релевантный одной задаче. Модель подобрана под сложность. Ты не платишь за Opus, когда нужен Haiku, и не тянешь полуторачасовую историю в простую правку.

Чтобы не забывать про новый чат — добавь в CLAUDE.md правило:

Когда задача полностью завершена, добавляй в конце ответа напоминание: «Задача закрыта. Если следующая несвязанная — открой новый чат.»

Модель будет сама подсказывать. На первое время это дисциплинирует лучше любых волевых усилий.

4. Prompt caching — почти бесплатная оптимизация для API

Ещё до 10 раз на повторных запросах с одним системным промптом.

У Anthropic есть кеширование промпта: когда ты отправляешь запрос, части промпта, помеченные как кешируемые, сохраняются на серверах Anthropic на 5 минут. Повторный запрос в этом окне — и кешированная часть стоит в 10 раз дешевле обычного чтения.

Работает это на системном промпте, документах, которые ты прикрепил к чату, описаниях инструментов. На всём, что не меняется от turn к turn.

Если ты на Claude Code или Cursor, кеширование происходит автоматически. Твой CLAUDE.md кешируется, первый запрос в новом чате дорогой, следующие 5 минут — в 10 раз дешевле. Поэтому длинный системный промпт не так страшен, как кажется по цифрам: его стоимость амортизируется через повторы.

Если работаешь с API напрямую, надо явно помечать cache_control: {type: "ephemeral"} на контенте, который хочешь кешировать. Это одна строчка в запросе.

Короче, в Claude Code это уже работает за тебя. Но механику знать полезно: она объясняет, почему /clear делает сессию свежее и дешевле. После сброса следующий turn заново прогревает кеш, а дальше всё катится по десятипроцентной стоимости.

У OpenAI есть аналогичная функция под названием prompt caching. Работает похоже, но условия и TTL отличаются.

5. RTK — сжатие вывода bash-команд

60–90% на выводе консольных команд, автоматически.

Когда Claude запускает git log, pytest, npm run build, docker compose up, вывод этих команд попадает в контекст целиком. Полный стектрейс со всеми строками. Весь лог сборки с прогресс-барами и предупреждениями. История коммитов за полгода.

И там много мусора: дублирующиеся строки, форматирование, цветовые escape-коды, повторяющиеся пути.

RTK, Rust Token Killer, — CLI-прокси, который перехватывает вывод команд и сжимает его до того, как он попадёт к модели. Там 4 стратегии: умная фильтрация, группировка, усечение с сохранением контекста и обработка вывода больших проектов.

Умная фильтрация убирает комментарии, пробелы, шаблонный код. Группировка собирает однотипные ошибки в один блок с count. Усечение режет длинные логи, но сохраняет начало, конец и маркеры середины.

Цифра у меня своя — rtk gain за месяц использования показывает около 89% среднего сокращения на ~3000 командах. Понятно, что на другом проекте с другим соотношением команд результат будет другим. Но порядок 60–90% устойчивый.

Это значит, что сессия живёт до context limit заметно дольше — при том же объёме работы.

Отдельно про десктоп. Многие думают: я работаю в Claude Desktop или ChatGPT-приложении, RTK мне не нужен. На самом деле нужен. Приложения тоже запускают команды под капотом, когда агент просит что-то сделать в терминале. Вывод этих команд так же попадает в контекст, как и в CLI. RTK ставится системно и перехватывает bash везде.

Ограничение: RTK работает только с Bash-инструментом. Встроенные Read, Grep, Glob в Claude Code через RTK не проходят — там Claude сам работает с файлами через SDK, без shell.

Установка:

brew install rtk
# или
cargo install --git https://github.com/rtk-ai/rtk

# интеграция в Claude Code
rtk init -g  # -g означает глобально, на все проекты

После этого в ~/.claude/settings.json появится PreToolUse hook, который автоматически перехватывает все bash-вызовы. Работает прозрачно, ничего в процессе не меняется.

6. PDF → Markdown: разные подходы

40–60% на каждом использовании документа, если один раз привести его в порядок.

Сырой PDF — плохой формат для LLM. Там форматирование, метаданные, иногда дублирующиеся блоки навигации, колонтитулы на каждой странице, непарсящиеся изображения и капризные колонки. Всё это попадает в контекст и жрёт токены.

Markdown — то, что LLM читает лучше всего: минимум разметки, максимум содержания, структура сохраняется в заголовках и списках.

Плюс тут есть инвестиционная логика: конвертируешь 1 раз — экономишь каждый раз при использовании.

Три способа, по ситуации.

Способ 1. Консольная утилита. MarkItDown от Microsoft специально сделан для подготовки документов под LLM. Поддерживает PDF, DOCX, PPTX, XLSX, HTML, изображения. Сохраняет структуру.

pip install markitdown
markitdown report.pdf > report.md

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

Способ 2. Свой скилл. Написать скилл типа /popovs:doc-to-md, который ты кладёшь в репо, и он автоматически конвертирует документы при первой работе с ними. Плюс — работает прямо в твоём процессе. Минус — надо сесть и написать.

Способ 3. Кросс-модельная конвертация. Если в одной модели токены жалко, а в другой — нет, можно перегнать документ через неё. Например, конвертировать PDF в Markdown через ChatGPT, а работать потом в Claude. Или наоборот. Работает, если у тебя подписка в обоих местах.

Обратная сторона: дорого не только парсить, но и генерировать

Если твоя задача заканчивается PDF на выходе — презентацией, отчётом, договором — генерация тоже жрёт токены. И не просто жрёт, а дважды: сначала модель пишет контент, потом ты просишь её подогнать оформление, потом переделываешь, потом ещё раз.

Два правила, которые это ломают.

Правило 1. При первой генерации сразу укажи стили, разметку, структуру, всё, что хочешь получить в финале. Не «напиши текст, потом оформим», а «напиши текст с такими заголовками, таким списком, такой таблицей». Это экономит итерации.

Правило 2. Делай PDF только 1 раз в самом конце. Все промежуточные этапы — в Markdown. Обсуждаешь структуру в MD. Редактируешь текст в MD. Показываешь коллегам MD. И только когда всё согласовано — конвертируешь в PDF через pandoc, браузерный Print to PDF или weasyprint.

Это банально, но я раз 5 видел, как люди генерят финальный PDF 10 раз подряд, переделывая мелочи.

7. MCP-серверы: изоляция вместо «везде подключено»

10–30% на системном промпте — за счёт того, что не таскаешь лишнее.

MCP, Model Context Protocol, — способ подключить к модели внешние сервисы: Notion, Confluence, GitHub, Slack, базы данных, платёжки. Штука полезная, но с коварным нюансом.

Когда ты подключаешь MCP-сервер, в системный промпт каждой сессии добавляется описание всех его инструментов и схем. У Notion это примерно 15 инструментов с описаниями. У GitHub — больше. У Confluence — под 3 десятка. И всё это грузится в каждый чат, даже если в этом проекте ты Notion не трогаешь.

В итоге ты подключаешь 5 MCP на всякий случай, и системный промпт разрастается на 20–30 тысяч токенов только за счёт описаний инструментов, которыми в конкретном проекте не пользуешься.

Решение — изоляция MCP по проектам.

Подключай MCP не через глобальные плагины Claude Code или Codex, где сервер цепляется на всё подряд, а напрямую через проектные конфиги. Это даёт контроль: в каком проекте какие серверы активны.

Если работаешь в пустом проекте без внешних интеграций — никаких MCP в контексте нет вообще.

Пример с Git хорошо иллюстрирует принцип.

У тебя есть 2 способа работать с Git через агента. Первый — плагин-MCP, подключённый к агенту: ты говоришь «закоммить и запушь», агент вызывает инструменты, всё происходит. Второй — руками: git commit, git push в терминале или через GUI вроде GitHub Desktop.

Если считать в токенах, второй способ в 2–3 раза дешевле. Плагин каждый раз тащит в контекст описание своих инструментов и диалог о том, какую команду вызвать. А прямой вызов через Bash-инструмент плюс RTK — это одна строка вывода.

MCP не зло. Он имеет смысл там, где реально нужна агентность: создать issue с кучей контекста, найти связанную страницу в Confluence и прочитать её, обновить страницу в Notion по шаблону.

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

8. Язык системного промпта

30–50% на системном промпте — но с оговоркой.

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

Причина снова в BPE-токенайзере. Русский текст режется на более мелкие куски, чем английский, потому что русского в обучающих данных было мало. По оценкам, то же самое содержание на русском занимает в 2–3 раза больше токенов, чем на английском.

Есть ещё одна деталь, о которой спорят. Некоторые исследования говорят, что модели, обученные в основном на английском тексте, внутренне думают в английском latent space — и русский ввод обрабатывается хуже не только из-за токенайзера, но и из-за самого представления.

Но это гипотеза, а не установленный факт.

Надёжно подтверждено одно: русский стоит в 2–3 раза больше токенов на тот же смысл. Этого уже достаточно, чтобы задуматься.

Вопрос в другом: готов ли ты к этому.

Системные промпты типа CLAUDE.md и AGENTS.md — технические инструкции для модели. Их может быть ок писать на английском: читать придётся редко, редактировать тоже. Плюс техника на английском звучит лаконичнее.

Чат с моделью — другое дело. Если тебе комфортнее думать на русском и формулировать задачи на русском, не надо себя ломать ради экономии. Качество твоей задачи и формулировки важнее стоимости токенов.

Есть промежуточный вариант — писать системный промпт в одном файле на русском, чтобы самому было удобно, и генерировать английскую версию через скрипт-интерпретатор, который будет подставляться в реальные настройки. Но это замороченно. Имеет смысл, только если ты пишешь большой промпт для команды и хочешь поддерживать его одновременно на 2 языках.

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

9. Caveman-стиль для системного промпта

Заметная экономия на длинных промптах — цифры ниже.

Caveman — подход к написанию инструкций для модели в предельно коротком, телеграфном стиле. Убираются все связующие слова, артикли, вежливости, пояснения. Остаётся чистый сигнал.

Плохо:

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

Хорошо:

Без моков в тестах. Только реальная БД.

Модель понимает обе формулировки. Но вторая короче в 5 раз.

По бенчмаркам автора открытого скилла Caveman — экономия 14–21% на структурных промптах, до 40% на длинных чат-диалогах. Это скромнее, чем заявленные в ранних обсуждениях 75%, но заметно на длинных сессиях.

Два способа применения.

Способ 1. Скилл Caveman. Есть готовый открытый репозиторий с Claude Code skill, который автоматизирует подход. Подключаешь скилл, настраиваешь, дальше модель сама пишет в caveman-стиле.

Способ 2. Вручную через CLAUDE.md. Просто напиши в системном промпте:

Write short. Drop filler, pleasantries, hedging. Fragments OK. Signal over politeness.

Модель начинает отвечать короче. Работает почти всегда без отдельного скилла.

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

10. Размер и структура системного промпта

10–30% в зависимости от того, сколько у тебя сейчас в промпте.

Системный промпт стоит токенов в каждом turn. Если у тебя там 5000 токенов, каждый запрос начинается с 5000 токенов. Умножь на 100 turn в день.

Три конкретных рычага.

skillListingMaxDescChars. По умолчанию Claude Code разрешает каждому скиллу иметь описание до 1536 символов, и все описания едут в системный промпт. Если у тебя 10 скиллов, это 15000+ символов только на описания. Выставь 300 — этого хватает, чтобы модель понимала, когда вызвать скилл.

{ "skillListingMaxDescChars": 300 }

Load-on-demand. Редко используемые инструкции не надо держать в AGENTS.md. Выноси в отдельные файлы и подключай при необходимости через @./docs/ai/ml.md. Работает в Claude Code и Cursor. Так делают с ML-гайдами, языко-специфичными инструкциями, чек-листами для специфических задач.

Ревизия. Раз в месяц — глазами пройтись по AGENTS.md и CLAUDE.md. Убрать устаревшие правила. Убрать то, чему модель всегда следует без напоминания. Такие инструкции часто дублируют то, что уже заложено в её поведение. Убрать пункты, которые ты забыл, зачем добавлял.

На моём AGENTS.md такая ревизия дала ощутимый результат. Изначально было 8000+ токенов правил, которым я когда-то зачем-то научил модель. Прошёлся глазами — половину выкинул. Остались те, которые реально меняют поведение.

Качество ответов — то же. Плюс теперь я знаю, что в файле, и могу объяснить каждое правило зачем. До ревизии — не мог.

11. autoCompactWindow — ранний триггер компакции

10–25% на длинных сессиях, одной строкой в конфиге.

Claude Code автоматически запускает компакцию, когда контекст приближается к лимиту. По умолчанию это происходит поздно: когда контекст уже большой, каждый turn дорогой, и context rot вовсю работает против тебя.

Настройка autoCompactWindow позволяет выставить более ранний порог. Минимум — 100000 токенов.

{ "autoCompactWindow": 150000 }

При таком значении модель сделает саммари истории раньше, и дальше сессия пойдёт с более чистым и коротким контекстом. Сэкономишь и на стоимости, и на качестве ответов.

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

12. Сжатие ответов модели

10–20% на выходных токенах.

Помнишь, что выходные токены стоят $15 за миллион у Sonnet? Длинный развёрнутый ответ дороже короткого. Если в промпте нет явной инструкции быть кратким, модель по умолчанию пишет развёрнуто: вводные абзацы, «важно отметить», «стоит обратить внимание», финальные резюме.

Добавь в CLAUDE.md блок compression:

## Response compression
Short by default: 3–7 sentences. Expand only when task requires detail.
Drop filler: «конечно», «безусловно», «по сути», «в принципе».
Drop pleasantries: «отличный вопрос», «с удовольствием».
Drop hedging: «возможно стоит отметить», «следует учитывать».

Одна оговорка. Это правило — только для ответов модели тебе в чате. Оно не должно применяться к генерируемому контенту: коммитам, PR-описаниям, постам, статьям, документации. Там нужна нормальная человеческая речь, а не caveman.

В моём репозитории это разделено через 2 модуля: style.md для чата с компрессией, writing-voice.md для генерируемого контента без неё.

Quick wins: что сделать уже завтра

Если я что-то и вынес из этой истории с $130, так это простую вещь: сначала измерь, потом чини. Без цифр это оптимизация вслепую.

Поставь ccusage. npx ccusage@latest — и увидишь свои траты по дням, сессиям и моделям. Запусти утром в понедельник, посмотри, что было за прошлую неделю, и ты уже знаешь, куда целиться.

Установи RTK один раз. rtk init -g — и вывод bash-команд автоматически сжимается на 60–90%. Работает в фоне.

Выстави дефолтную модель. В ~/.claude/settings.json: "model": "claude-sonnet-4-6". Sonnet для большинства задач, переключаешь на Haiku или Opus только когда нужно.

Добавь подсказки в CLAUDE.md. Правило, чтобы модель подсказывала, какая модель подходит для следующей задачи. И правило про «задача закрыта — открой новый чат». Дисциплинирует быстрее силы воли.

Настрой ранний autoCompact. "autoCompactWindow": 150000. Одна строка в settings.json — компакция срабатывает раньше, контекст не раздувается.

Ограничь описания скиллов. "skillListingMaxDescChars": 300. Сэкономит пару тысяч токенов в системном промпте, если у тебя много скиллов.

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

Для документов — markitdown. Повторно используемые PDF конвертируй в Markdown через markitdown file.pdf > file.md. Генерируй PDF только в самом конце, промежуточные этапы — в Markdown.

Дальше — язык промпта, Caveman, размер CLAUDE.md. Это уже полировка, но тоже работает.

Что уже собрано и готово к использованию

Я прошёл этот путь и собрал самое важное в публичный репозиторий с настройками для AI-агентов.

Там не всё из статьи — специально. RAG, например, не собрано, потому что это отдельный продукт, а не настройка. Но базовая гигиена есть.

Что внутри:

— RTK с автоматической установкой через scripts/install.sh — Раздел Compression в системном промпте — Настройки skillListingMaxDescChars, autoCompactWindow — Sonnet как глобальный дефолт — Подсказки по выбору модели и effort в конце каждого ответа модели — Напоминание про новый чат при завершении задачи — Разделение инструкций: чат со сжатием и генерируемый контент без сжатия — Скиллы для коммитов, PR, changelog — написанные в правильном голосе

Установка одной командой разворачивает всё в нужные места: ~/.claude/, ~/.codex/AGENTS.md, ~/.cursor/, ~/.gemini/. Поддерживает Claude Code, Codex CLI, Cursor, Gemini CLI.

Репозиторий — github.com/tsergeytovarov/ai-settings.

Это не «клонируй и забудь». Там есть гайд по кастомизации: что править под себя, что не трогать. База рабочая, проверена на реальных проектах — бери и развивай под свои процессы.

А я пойду дальше жечь токены. Теперь хотя бы осознанно)

Словарь терминов

Токен — минимальная единица текста для LLM. ~0.75 слова на английском, ~0.25 на русском.

BPE — Byte-Pair Encoding, алгоритм, которым токенайзер режет текст на куски.

Контекстное окно — всё, что модель держит в памяти одновременно. У Claude 4.6 — до 1M токенов.

Context rot — деградация качества ответов по мере роста контекста.

Компакция — автоматическое сжатие истории чата в саммари.

Prompt caching — кеширование системного промпта на сервере провайдера. Повторный запрос в течение 5 минут стоит в 10 раз дешевле.

RAG — Retrieval-Augmented Generation, архитектура, при которой в контекст летят только релевантные куски базы знаний.

Embeddings — числовые векторы, в которые превращается текст для семантического поиска.

Vector DB — база для хранения и поиска по векторам.

System prompt — системный промпт, инструкции для модели, которые грузятся в каждый turn. CLAUDE.md, AGENTS.md.

RTK — Rust Token Killer, CLI-прокси, сжимающий вывод bash-команд до попадания в контекст.

MCP — Model Context Protocol, стандарт для подключения внешних сервисов к модели.

ccusage — CLI-инструмент для анализа расхода токенов в Claude Code.

Haiku / Sonnet / Opus — 3 модели Claude. Haiku — быстрая и дешёвая, Opus — мощная и дорогая.

Caveman — подход писать инструкции для LLM в предельно коротком стиле без связующих слов.