Как выжать максимум из Claude Code с контекстом 1 млн токенов: сессии, compact и субагенты — VogueTech

Что нового

Anthropic обновила Claude Code и сделала две ключевые вещи:

Контекст 1 000 000 токенов в Claude Code
Теперь среда разработки Claude Code может держать в памяти до миллиона токенов. В этот объём входят:
- системный промпт;
- вся история диалога;
- все вызовы инструментов и их ответы;
- содержимое прочитанных файлов.
Это позволяет вести очень длинные сессии: от многочасового дебага до разработки полнофункционального приложения, не обрывая диалог каждые пару шагов.
Новый slash‑инструмент для анализа использования Claude Code
Anthropic добавила отдельную команду (slash‑команду) внутри Claude Code, которая помогает понять, как вы расходуете контекст и как ведёте сессии. В оригинале команда упоминается без имени, но по сути это инструмент «посмотреть на свои паттерны использования»:
- сколько у вас длинных сессий;
- когда чаще всего срабатывает автокомпакт;
- насколько вы полагаетесь на rewind, compact и субагентов.

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

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

Контекст и «context rot»

Контекст — это всё, что Claude 4 (в режиме Claude Code) «видит» в момент ответа. Чем он больше, тем больше информации модель должна удерживать в фокусе. При миллионе токенов возникает эффект, который Anthropic называет context rot:

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

Контекст в Claude Code — это жёсткое ограничение. Когда вы подбираетесь к потолку в 1M токенов, система запускает compaction:

модель получает задание: «суммаризируй всё, что происходило в этой сессии»;
превращает длинную историю в более короткое описание с ключевыми выводами и файлами;
дальше работа продолжается уже поверх этой сжатой версии, в новом окне контекста.

Compaction может запуститься автоматически, а вы можете вызвать его вручную, когда понимаете, что сессия разрослась и начала «тупить».

Ветвления на каждом шаге

Каждый ваш запрос к Claude Code — это точка ветвления. После очередного ответа у вас есть несколько вариантов:

Продолжить в той же сессии
Просто пишете следующий промпт. Весь контекст сохраняется, растёт и постепенно портится от context rot.
Rewind (двойной Esc)
В Claude Code двойное нажатие Esc или соответствующая команда позволяет вернуться к любому предыдущему сообщению и перепромптить с этого места. Всё, что было после выбранной точки, вылетает из контекста. Это даёт чистый ответвлённый сценарий: «а что, если бы я с самого начала попросил по‑другому?»
Новая сессия
Старт с нуля, обычно с коротким брифом, который вы выжали из прошлой работы. История не тянется за вами, но вы можете пересказать важные вещи вручную.
Compact
Вызываете compaction сами. Claude Code суммаризирует сессию, заменяет длинную историю кратким описанием и продолжает поверх него. Это «автоконспект» вашей работы.
Субагенты (subagents)
Claude Code может породить отдельного агента через Agent‑tool. У субагента свой чистый контекст. Он делает много промежуточной работы, а в основную сессию возвращается только финальный отчёт.

Все эти варианты — по сути разные способы управлять контекстом, а не просто «стиль общения».

Compaction против новой сессии

Anthropic чётко разводит два подхода к очистке контекста:

Compact
- Claude сам пишет сводку диалога и заменяет ей историю.
- Вы ничего не формулируете вручную.
- Суммаризация всегда «с потерями», но модель часто аккуратно вытаскивает важные файлы и выводы.
- Поведение можно направить инструкциями — передать, что именно важно сохранить.
Новая сессия + ручной бриф
- Вы сами описываете, что важно: «рефакторим auth‑middleware, ограничения такие‑то, важные файлы A и B, подход Y не подходит».
- Начинаете с чистой истории, без мусора от прошлых попыток.
- Больше работы руками, но итоговый контекст именно такой, как вы решили.

Почему autocompact иногда работает плохо

Anthropic честно признаёт: автокомпакт не всегда угадывает ваш следующий шаг.

Типичный сценарий:

вы долго дебажите один баг, читаете кучу файлов;
где‑то по пути мелькает ещё одно предупреждение в bar.ts;
в конце автокомпакт срабатывает и суммаризирует «длинный дебаг»;
вы пишете: «теперь поправь то другое предупреждение в bar.ts»;
но в summary второе предупреждение не упомянуто, потому что весь фокус был на первом баге.

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

С контекстом в 1M токенов у вас появляется больше времени, чтобы самому вызвать /compact заранее и подсказать Claude, что нужно сохранить: цель, ограничения, список файлов, найденные тупики.

Субагенты и отдельные окна контекста

Когда Claude Code создаёт субагента через Agent‑tool, этот субагент получает полностью отдельное окно контекста:

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

Внутренний тест Anthropic звучит так: «Мне понадобится именно весь вывод инструмента или только выводы?»
Если нужны только выводы — хорошая кандидатура для субагента.

Claude Code и сам умеет решать, когда создать субагента, но Anthropic предлагает и прямые формулировки, которые помогают управлять этим вручную:

«Запусти субагента, который проверит результат работы по вот этому спецификационному файлу»;
«Запусти субагента, чтобы он прочитал другой кодовой базис и описал, как там реализован auth‑flow, а потом повторил этот подход у нас»;
«Запусти субагента, чтобы он написал документацию по этой фиче на основе моих git‑изменений».

Что это значит для вас

Когда держать длинную сессию, а когда начинать заново

Anthropic даёт простой ориентир: новая задача — новая сессия.

Если вы перешли от «починить баг в логике» к «спроектировать новую фичу», лучше стартовать новый диалог.
Если задача та же, но вы ушли в тупик — используйте rewind, а не бесконечные уточнения.

Контекст в 1M токенов соблазняет вести одну вечную сессию «со всем проектом», но это почти всегда приводит к context rot и странным ответам.

Когда выгоднее rewind, а не «поправь, пожалуйста»

Пример из текста Anthropic:

Claude прочитал пять файлов, предложил подход, вы его попробовали — не сработало.
Инстинкт: «Это не сработало, попробуй X».
Лучше: rewind к моменту сразу после чтения файлов и новый промпт:
«Не используй подход A, модуль foo не даёт такой возможности — сразу иди по пути B».

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

Дополнительно можно использовать режим «summarize from here» или slash‑команду, чтобы Claude сам написал «письмо себе из будущего»:

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

Когда делать compact, а когда вручную пересказывать задачу

Используйте compact, когда:

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

Делайте новую сессию с ручным брифом, когда:

вы завершили этап работы и начинаете следующий (например, после реализации — документация);
вам важно жёстко контролировать, какие файлы и решения останутся в фокусе;
вы хотите избавиться от «исторического шума» — старых обсуждений, временных костылей и пр.

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

Когда запускать субагентов

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

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

Вопрос, который стоит себе задавать:
«Мне нужны будут промежуточные логи или только финальный отчёт?»

Если нужны только выводы, субагент разгрузит основную сессию и сэкономит вам контекст.

Доступность в России

Claude Code — часть экосистемы Anthropic. Прямой доступ к Claude.com и связанным продуктам может быть ограничен в России и потребовать VPN.
Anthropic официально не ориентирует Claude Code на российский рынок, поэтому для стабильной работы придётся использовать зарубежный аккаунт и обходные способы доступа.

Место на рынке

Anthropic в этом материале не даёт ни цен, ни сравнений с конкурентами вроде GPT‑4o или других IDE‑ассистентов, поэтому сравнивать производительность и стоимость некорректно.

Из конкретики у нас есть только одно твёрдое число — 1 000 000 токенов контекста в Claude Code и описание того, как Anthropic предлагает этим контекстом управлять:

длинные сессии с автокомпактом;
ручной compact, когда вы хотите сохранить суть и выкинуть шум;
rewind как основной способ «откатить» неудачную ветку;
субагенты с отдельными окнами контекста для тяжёлых подзадач.

Фактически Anthropic делает ставку не только на «большой контекст», но и на инструменты управления памятью внутри IDE‑опыта. Насколько это быстрее или дешевле решений от других игроков, можно будет судить только по независимым тестам.

Как использовать Claude Code эффективнее: практические сценарии

1. Разработка фичи от идеи до документации

Рекомендуемый маршрут от Anthropic можно свести к такому паттерну:

Новая сессия: формулируете задачу и ограничения.
Чтение кода: даёте Claude Code прочитать релевантные файлы.
Реализация: несколько итераций кода и тестов.
Rewind при неудаче: если подход провалился — откат к моменту после чтения файлов и новый промпт.
Compact после завершения реализации: чтобы сохранить краткую историю фичи.
Субагент для документации: поручаете отдельному агенту написать доки по git‑изменениям, а в основную сессию возвращаете только итоговый текст.

2. Долгий дебаг с множеством тупиков

Начинаете сессии с описания бага и окружения.
Даёте Claude Code прочитать логи и ключевые файлы.
На каждую неудачную ветку дебага используете rewind, а не «попробуй ещё вот это».
Когда понимаете, что баг закрыт, запускаете ручной /compact и явно говорите, что важно сохранить:
- корневую причину;
- файлы, где правили код;
- решения, которые не подошли.
После этого можете спокойно переходить к смежным задачам (например, оптимизации) в той же сессии.

3. Исследование чужой кодовой базы

В основной сессии формулируете цель: «понять, как реализован auth‑flow».
Просите Claude Code создать субагента, который прочитает весь проект и вернёт:
- архитектуру аутентификации;
- ключевые точки входа;
- список важных файлов.
В основной сессии получаете короткий отчёт и уже по нему задаёте уточняющие вопросы, не утопая в логах чтения сотен файлов.

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