4 способа не потерять контекст Claude Code

Я, Арина Михална, знаю, что контекст агент переполнение на длинных задачах в Claude Code — это не баг, это физика. Контекстное окно конечно, и когда оно забивается историей команд, логами и промежуточными результатами, агент теряет нить и начинает делать что-то своё.

Я, Арина Михална, запускала рефакторинг легаси-кода на несколько тысяч строк. Час работы — всё хорошо. Два часа — агент начал переписывать уже готовые файлы. Три часа — он «забыл» исходную задачу и занялся оптимизацией, о которой я не просила. Без понимания того, как работает контекст, такие сессии всегда заканчиваются рестартом с нуля.

Почему агент теряет задачу: механика переполнения

Claude Code работает как любая языковая модель: он видит только то, что помещается в контекстное окно. Всё, что туда не влезло, для него не существует.

На коротких задачах это не проблема. На длинных — критично. Вот что постепенно вытесняет исходную задачу:

Артефакт	Типичный размер	Скорость накопления
Стектрейс ошибки (50 строк)	500–800 токенов	каждая ошибка
Кодовый файл (200 строк)	1500–2500 токенов	каждый прочитанный файл
История команд за час	5000–10 000 токенов	постепенно
Полный stdout за сессию	10 000–20 000 токенов	быстро на больших проектах
Исходная постановка задачи	200–500 токенов	один раз, в начале

Видишь проблему? Постановка задачи — крошечная. Шум — огромный. Когда контекст забивается под завязку, модель начинает «домысливать» цель по тому, что сейчас видит перед глазами. А видит она последние логи и последние файлы.

Это не агент сломался. Это не баг, это физика. Контекст конечен, шум бесконечен, и задача без якоря тонет.

Механизм 1: якорь цели в CLAUDE.md

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

Структура рабочего якоря в CLAUDE.md:

## ТЕКУЩАЯ ЗАДАЧА
Цель: рефакторинг модуля auth/ — разделить на три
независимых файла
Статус: готовы user.ts и session.ts, осталось permissions.ts
Запрещено: трогать файлы вне auth/, менять API-контракты

## СДЕЛАНО В ЭТОЙ СЕССИИ
- [ ] user.ts — готово
- [ ] session.ts — готово  
- [ ] permissions.ts — в работе

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

Подробнее про структуру CLAUDE.md для сложных проектов — в статье про файл памяти проекта.

Механизм 2: принудительное сжатие через /compact

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

Когда запускать:

Сигнал	Что делать
Агент начал повторять уже сделанные шаги	/compact немедленно
Сессия идёт больше 45–60 минут	/compact профилактически
В контексте накопилось много stdout и логов	/compact перед следующим большим шагом
Агент «забыл» ограничение, которое ты ставил	/compact + повторить ограничение явно

Механизм 3: контрольные точки с записью статуса

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

Как это выглядит на практике. Перед каждым крупным блоком работы — явная инструкция агенту:

Прежде чем продолжить, выполни три шага:
1. Список файлов, которые ты изменил за эту сессию
2. Что осталось сделать по исходной задаче
3. Есть ли что-то, что мешает двигаться дальше

После этого запиши статус в CLAUDE.md и только потом
переходи к следующему шагу.

Это не бюрократия. Это страховка от того, что агент уйдёт в сторону на этапе, где он уже не видит начала пути.

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

Механизм 4: разделение задачи между сессиями с чёткими артефактами

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

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

Сессия 1: анализирует legacy-код → выдаёт analysis.json
Сессия 2: читает analysis.json → пишет тесты → выдаёт
test-report.md
Сессия 3: читает test-report.md → делает рефакторинг →
коммитит

Каждая сессия видит только свою задачу и свои данные. История чужих сессий не засоряет контекст. Если что-то сломалось в сессии 2, сессия 3 об этом не знает и не «заражается» чужими ошибками.

Больше про параллельные сессии и передачу состояния — в статье про несколько сессий одновременно.

Как оценить, что съедает контекст быстрее всего

Не все артефакты в контексте равны. Некоторые компактные и полезные, другие — огромные и бесполезные. Таблица реальных замеров:

Артефакт	Токенов	Полезность на длинной задаче	Стоит ли держать в контексте
Постановка задачи (3 абзаца)	200–500	Критична всегда	Да, через CLAUDE.md
Кодовый файл 200 строк	1500–2500	Высокая, если редактируется	Да, пока работаешь с ним
Стектрейс (50 строк)	500–800	Высокая сразу после ошибки	Нет, после исправления
История команд за час	5000–10 000	Низкая	Нет, сжать через /compact
Полный stdout за сессию	10 000–20 000	Почти нулевая	Нет, вообще не держать
Список зависимостей package.json	300–600	Средняя	Только при установке/обновлении

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

Типология задач: где контекст критичен, где нет

Не все задачи одинаково чувствительны к переполнению контекста. Есть те, которые ломаются от потери цели, и те, которые переживут даже полный рестарт.

Тип задачи	Чувствительность к контексту	Почему	Что делать
Рефакторинг легаси-кода (500+ строк)	Очень высокая	Агент должен помнить, что уже поменял и что ещё нет	CLAUDE.md + чекпоинты + /compact каждые 40 мин
Написание нового модуля с нуля	Средняя	Можно начать заново, если не успел закоммитить	Чекпоинты + артефакты в файлы
Дебаг одной функции	Низкая	Задача локальная, контекст не разрастается	Ничего специального
Миграция API на новую версию	Очень высокая	Много файлов, зависимостей, легко пропустить кусок	Разделение на сессии + чёткий чек-лист в CLAUDE.md
Генерация тестов для готового кода	Средняя	Тесты почти независимы, но нужно помнить структуру	CLAUDE.md с описанием архитектуры

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

Post-mortem: как я потеряла три часа работы из-за контекста

Рефакторил большой React-компонент. Тысяча строк в одном файле, надо было разнести на пять маленьких. Сессия шла два с половиной часа. Агент сделал четыре файла из пяти, всё компилировалось, тесты зелёные.

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

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

Что помогло бы:

1. CLAUDE.md с чек-листом из пяти файлов и статусом каждого.
2. /compact после третьего файла, когда контекст ещё был управляемым.
3. Чекпоинт перед пятым файлом: «Выпиши, что ты сделал в четырёх предыдущих, и только потом начинай пятый».

Сейчас делаю все три. Сессии на два часа проходят без срывов.

Архитектуры для больших проектов: как не коллапсировать

Когда проект больше 10–15 файлов, ни один из механизмов выше не спасёт в одиночку. Нужна архитектура разделения труда между агентами.

Вариант 1: вертикальное разделение по фичам.

Агент 1 (сессия 1): модуль авторизации
Агент 2 (сессия 2): модуль платежей
Агент 3 (сессия 3): модуль уведомлений

Каждый агент работает в своей папке и видит только свои файлы. Контекст не раздувается, потому что чужой код его не касается. Связь — через API-контракты, которые записаны в корневом CLAUDE.md и доступны всем сессиям.

Вариант 2: горизонтальное разделение по этапам.

Агент 1: пишет код
Агент 2: пишет тесты на основе кода из шага 1
Агент 3: делает ревью и рефакторинг

Каждая сессия получает артефакт предыдущей в виде файлов. История переписки не передаётся. Если агент 1 накосячил, агент 2 об этом узнает только из кода, а не из контекста — это защита от «заражения» чужими ошибками.

Вариант 3: мультиагентный конвейер с координатором.

Один агент (главная сессия) ставит задачи и собирает результаты. Остальные — исполняют и отдают артефакты обратно. Главный держит в контексте только статусы и итоговые файлы, не промежуточный мусор.

Подробнее про связку агентов — в статье как собрать агента на Claude.

Готовые скрипты для автоматического управления контекстом

Если агент не может сам следить за контекстом, можно научить его делать это автоматически через git-хуки и скрипты.

Pre-commit hook: записать статус в CLAUDE.md перед коммитом.

#!/bin/bash
# .git/hooks/pre-commit

echo "## Последний коммит: $(date)" >> CLAUDE.md
echo "Изменённые файлы:" >> CLAUDE.md
git diff --cached --name-only >> CLAUDE.md
echo "" >> CLAUDE.md

Перед каждым коммитом автоматически обновляется файл памяти. Агент всегда видит, что было сделано в последнем шаге.

Скрипт для автоматического /compact каждые N минут.

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

import time
from anthropic import Anthropic

client = Anthropic()
session_start = time.time()

while task_not_done:
    response = client.messages.create(...)
    
    if time.time() - session_start > 2400:  # 40 минут
        client.messages.create(
            model="claude-sonnet-4-20250514",
            messages=[{"role": "user", "content":
"/compact"}]
        )
        session_start = time.time()

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

Алиас для быстрого чекпоинта.

Добавь в .bashrc или .zshrc:

alias checkpoint='echo "CHECKPOINT: $(date)" >> CLAUDE.md &&
git status >> CLAUDE.md'

Одна команда — и статус зафиксирован в файле памяти и в консоли. Агент увидит это при следующем запросе.

Сравнение с другими IDE: кто лучше держит контекст

Claude Code — не единственный инструмент для работы с агентами. Есть Cursor, GitHub Copilot Workspace, Codex CLI. У каждого свои механизмы управления контекстом.

Инструмент	Как управляет контекстом	Плюсы	Минусы
Claude Code	CLAUDE.md + /compact + ручные чекпоинты	Полный контроль, гибкость	Требует дисциплины
Cursor	Автоматическое сжатие + @-mentions для явных якорей	Удобно из коробки	Непрозрачно, что именно сжато
GitHub Copilot Workspace	Разделение на task chunks с артефактами	Хорошо для больших проектов	Нужна подписка Enterprise
Codex CLI	Каждая команда = новый контекст, состояние в Git	Простой, предсказуемый	Не держит состояние между командами

Claude Code выигрывает в прозрачности: ты видишь, что в контексте, и можешь управлять им вручную. Cursor удобнее, но менее контролируем. Codex проще, но не подходит для длинных задач.

Сравнение Claude Code и Codex на практике — тема отдельного разбора.

Чек-лист перед длинной сессией

• Записал цель задачи и текущий статус в CLAUDE.md
• Прописал запреты: что нельзя трогать, какие API не менять
• Разбил задачу на 3–5 подзадач с чёткими артефактами на выходе
• Поставил напоминание запускать /compact каждые 40–50 минут
• Настроил чекпоинты: после каждой подзадачи агент записывает статус
• Если задача касается больше 7 файлов — готов разделить на параллельные сессии

Если хотя бы три пункта не выполнены, длинная сессия кончится рестартом.

По материалам: исследование Context Engineering на MarkTechPost от 12 сентября 2026, официальная документация Claude Code.

Читайте также

• Claude Code оценка задачи: почему агент врёт
• Claude Code агент: расход токенов ×600
• Субагенты в Claude Code: AI-агенты 2026
• На портале «Мастерская нейросетей»: Как делегировать задачи нейросети Claude: рутина уходит из рук в 2026

Ситуация: сессия идёт третий час, агент начал делать странное, /compact уже не помогает, а откатывать всю работу жалко.

Порядок действий:

1. Стоп. Не давай агенту новых команд, пока не зафиксируешь, что уже сделано.
2. Попроси агента выписать статус: «Перечисли все файлы, которые ты изменил за эту сессию, и что осталось сделать по исходной задаче».
3. Запиши ответ в CLAUDE.md вручную. Не доверяй агенту это сделать самому — он может пропустить куски.
4. Закрой сессию, открой новую. Новая сессия = чистый контекст + автоматическое чтение CLAUDE.md.
5. В новой сессии дай чёткую команду: «Продолжи задачу с того места, где остановились — статус в CLAUDE.md. Не начинай сначала, не трогай готовые файлы».

Рестарт сессии — это не поражение. Это нормальная практика для задач длиннее двух часов. Главное — зафиксировать состояние до перезапуска.

Частые ошибки при управлении контекстом

Ошибка	Почему это ломает сессию	Как исправить
CLAUDE.md написан один раз и не обновляется	Агент видит устаревшую информацию и делает не то	Обновляй статус после каждой подзадачи
/compact запускается слишком поздно	Когда контекст уже забит, сжимать нечего полезного	Запускай каждые 40–50 минут, не дожидаясь проблем
Передаёшь между сессиями всю историю переписки	Новая сессия захлёбывается чужим мусором	Передавай только артефакты: файлы, JSON, markdown
Не прописываешь запреты явно	Агент трогает файлы, которые должны были остаться нетронутыми	Запреты — в CLAUDE.md, отдельным блоком, жирным шрифтом
Ставишь агенту задачу без чётких подзадач	Он импровизирует маршрут и теряется на полпути	Разбивай задачу на 3–5 шагов с конкретными результатами

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

Реальный пример: рефакторинг с тремя сессиями и чекпоинтами

Задача: переписать API-слой легаси-проекта. 12 файлов, 3000 строк кода, нельзя трогать базу данных и фронтенд.

Сессия 1: анализ и план.

Цель: прочитать все 12 файлов, выписать зависимости,
предложить порядок рефакторинга.
Вход: папка src/api/
Выход: файл refactor-plan.md с порядком действий и списком
рисков.

Результат: plan готов за 20 минут, контекст чистый. Сессию закрыл.

Сессия 2: рефакторинг первых 6 файлов.

Цель: переписать файлы 1–6 по плану из refactor-plan.md.
Запреты: не трогать БД, не менять API-контракты.
Чекпоинт: после каждых двух файлов записывать статус в
CLAUDE.md.

Через час работы агент сделал 4 файла. Я запустила /compact. Ещё через 40 минут — готовы все 6. Статус записан в CLAUDE.md, сессию закрыл.

Сессия 3: рефакторинг оставшихся 6 файлов.

Цель: закончить рефакторинг, файлы 7–12.
Вход: CLAUDE.md со статусом сессии 2 + refactor-plan.md.
Чекпоинт: после каждых двух файлов.

Ещё полтора часа — всё готово. Тесты зелёные, ничего лишнего не тронуто.

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

Больше про архитектуру таких задач — в статье про субагентов в Claude Code.

Инструменты мониторинга: как видеть, что творится с контекстом

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

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Сделай
рефакторинг"}]
)

# Логируй использование токенов
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")

if response.usage.input_tokens > 150000:
    print("⚠️ Контекст приближается к лимиту, пора делать
/compact")

Простой скрипт, но он спасает от внезапного переполнения. Видишь цифры — понимаешь, когда пора сжимать.

Для продакшн-агентов стоит смотреть на AgentOps или похожие инструменты мониторинга — они показывают динамику контекста в реальном времени. Подробнее про это — в статье про мониторинг агентов.

Когда четыре механизма не помогут

Бывают задачи, где управление контекстом не решает проблему. Например:

• Задача требует держать в голове 50+ файлов одновременно. Ни одна модель не справится, контекста не хватит физически. Решение: разделить проект на модули с изолированными контрактами.
• Агент должен помнить детали из двухнедельной истории работы. Контекст не резиновый. Решение: внешняя база знаний (векторный поиск, RAG) или длинная память через MCP.
• Задача меняется на лету, и исходная цель уже неактуальна. Механизмы работают, только если цель стабильна. Решение: переформулировать задачу явно и перезапустить сессию.

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

Про MCP и долгосрочную память агентов — в статье как дать Claude Code контекст на месяцы.