Контекст переполняется — что делать

Как понять, что контекст переполнен

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

• Ответы замедлились. Между моим сообщением и началом стрима — несколько секунд тишины. Это prefill — модель обрабатывает весь контекст заново.
• Claude забывает факты из начала разговора. Я в первом сообщении сказал «работаем над ErgonLab», через час он спрашивает «а это какой проект?».
• Путаница в файловых путях. Помнит, что что-то читал, но не помнит — что. Снова открывает те же файлы, тратит на них токены.
• Auto-compact срабатывает. В claude-hud видно, что система сама сжала контекст. Это работает, но качество всегда падает: сжатая версия теряет нюансы.

Если хотя бы два пункта сошлись — пора что-то делать.

Что жрёт контекст быстрее всего

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

• Большие файлы целиком. Особенно .json, лог-файлы, минифицированные бандлы, экспорты Telegram-чатов. Один такой файл — 20-50 тысяч токенов сразу.
• Длинные tool results без truncation. Например, npm install выдаёт 2 тысячи строк лога — все они летят в контекст. То же с длинным git log, ls -R, выводом тестов.
• Повторные reads. Я по ходу обсуждения два раза открыл один и тот же файл — он в контексте дважды. Если файл был 5К токенов, это уже 10К.
• Inline данные через bash. cat огромный_файл, head -1000 лог.log — всё это уходит в контекст так же, как Read.

Когда понимаешь, что главные пожиратели — это файлы и tool results, дальше техники становятся очевидными.

Семь техник, которыми пользуюсь сам

1. Subagents с background

Самое мощное средство. Subagent работает в своём контексте, не в моём. Я даю ему задачу: «прочитай 20 файлов, проанализируй, верни сводку» — у него крутится отдельная сессия с собственными 200К, и обратно прилетает только сжатый текстовый отчёт на 2-3 тысячи токенов.

Сегодня (14.05.2026) я как раз так работаю над сайтом ErgonLab. Запустил два параллельных subagent-окна — Окно А пишет одни статьи, Окно B пишет другие. Моя основная сессия не загружена их read-ами и write-ами вообще: я просто получу два отчёта в конце. А пока могу спокойно делать аналитику и принимать стратегические решения, не упираясь в потолок.

Правило, к которому пришёл: любая задача с большим объёмом чтения файлов = subagent. Если я сам читаю 10+ файлов — это была ошибка планирования.

2. Skill вместо повторяющегося промта

Если я каждый раз объясняю «когда пишешь пост в @ergonlab, используй эту структуру, эти эмодзи, эти теги» — это пожирает контекст в каждой сессии заново.

Skill /ergonlab-post хранит этот процесс. В сессии я просто говорю /ergonlab-post — и skill сам подтягивает инструкции, делает шаги, возвращает результат. Триггерится фразой, не висит в контексте, пока не нужен.

То же с /commit, /deploy, /review, /session-save. Все повторяющиеся процедуры — в skills.

3. Hooks вместо «всегда делай X»

Hook — это автоматическое действие на уровне системы, без AI. Если мне нужно «всегда форматировать TypeScript после правки» — это не инструкция Claude, это хук в settings.json, который запустит prettier сам.

Каждая такая «всегда»-инструкция, перенесённая в хук, экономит токены в каждой сессии. И качество выше — хук не забудет, в отличие от AI.

4. Persistent memory

В Claude Code есть MEMORY.md и memory/<topic>.md — это файлы фактов, которые подтягиваются точечно. Не «прочитай всё перед началом», а «когда речь зайдёт про конкретного клиента — открой его карточку».

У меня сейчас 60+ записей в memory: фидбек-правила, контекст клиентов, незавершённые сессии, исследования. В контекст влетает только то, что релевантно текущей задаче, не всё подряд.

Принцип такой: факт, который нужен в любой сессии — в ~/.claude/CLAUDE.md. Факт, который пригодится через месяц — в memory. В сессию они подтянутся ровно когда надо.

5. grep + head вместо cat

Когда работаю с большими файлами — не открываю их целиком. Алгоритм:

1. grep -n "ключевое_слово" path/to/file — найти строки
2. Read с offset и limit — прочитать ровно нужный кусок (например, строки 240-280)

В Bash подобное: sed -n '240,280p' file.log, head -100, tail -50. Это десятки сэкономленных тысяч токенов на больших логах и конфигах.

Особенно критично с JSON-дампами и экспортами Telegram. У меня были файлы экспорта на 200 тысяч строк — Read целиком убил бы сессию. Через jq и grep я вытаскиваю ровно один объект.

6. /session-save → новая сессия

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

Skill /session-save финализирует контекст: записывает в MEMORY.md что было сделано, что осталось, какие файлы трогали, какие решения приняты. Получается компактный handoff на 100-200 слов.

Открываю новую сессию — в неё подтягивается этот handoff из memory. По факту я начинаю работу с чистым 200К-контекстом, но при этом помню, на чём остановился.

Это лучше, чем тянуть переполненную сессию через auto-compact и страдать с тормозами и забывчивостью.

7. Read с offset и limit

Маленькая, но недооценённая техника. Если файл на 800 строк, а интересует только функция в строках 340-380 — Read с offset: 340, limit: 50.

Я приучил себя по умолчанию читать кусками. Открываю файл целиком только если он реально маленький (меньше 200 строк) или я с ним ещё незнаком. Дальше — точечные подгрузки.

Когда пора начинать новую сессию

Сигналы, по которым решаю «всё, надо рестартовать»:

• Auto-compact срабатывал больше двух раз. После двух сжатий качество падает заметно — модель теряет нюансы и сама не понимает, чего ей не хватает.
• Текущая задача завершена, начинается новая. Не тянуть старый контекст в новую тему — открыть свежую сессию.
• Появилось ощущение «Claude тупит». Это почти всегда переполнение, реже — устаревший CLAUDE.md. Сначала проверяю сессию.
• Прошёл день. На утро после сложного вечера всегда новая сессия. Контекст вчерашнего дня обычно уже не нужен в полном объёме — нужна сводка из memory.

Антипаттерны, в которые сам наступал

Открыть 30 файлов «на всякий случай». Я раньше любил «дать Claude максимум контекста» — открывал кучу связанных файлов перед задачей. Это пожирает 50-70К токенов на старте. Лучше открыть 3 ключевых, остальное — точечно по запросу.

Игнорировать subagents для крупных тасков. Если задача «прочитай и проанализируй много файлов» — это всегда subagent. Делать самому = убить сессию.

Запускать npm install или pytest без перенаправления. Длинный вывод тестов или установки летит в контекст. Если вывод не нужен для обсуждения — &> /dev/null или сохранить в файл и прочитать selectively.

Жалеть на новую сессию. Психологически кажется «ой, я же только что всё настроил, жалко». Реально — 2 минуты на /session-save и старт новой окупаются за час нормальной работы.

Что я делаю в первые 5 минут новой сессии

Привык к небольшому ритуалу:

1. Проверяю claude-hud — сколько контекста ушло на загрузку (CLAUDE.md, memory, agents). Если уже 20%+ — задумываюсь, не пора ли почистить.
2. Сразу формулирую задачу одним сообщением. Не «привет, начнём с того», а сразу суть.
3. Если задача большая — планирую subagent-стратегию. Что я делаю сам, что отдаю в фон.
4. Открываю только те файлы, которые точно нужны для первого шага. Остальное — по мере дела.

Так удаётся держать сессию рабочей часами без auto-compact и без падения качества.