# Maximizing the value in Claude Code: claude code workflow делим на этапы в 2026

> Anthropic объяснила, почему длинная сессия Claude Code постепенно дорожает. Разбираю, когда нажимать `/clear`, `/compact`, `/resume`, а когда отдавать работу subagent.

Источник: https://vibeceh.ru/novosti/maximizing-the-value-of-your-claude-code-sessions
Автор: Сергей Мазур · опубликовано 2026-08-15

`claude code workflow` начинается с управления сессией. Claude Code снова отправляет модели прочитанные файлы, вывод команд и историю разговора на каждом следующем ходе. Кэш делает повторную обработку дешевле, но не бесплатной. Поэтому крупную задачу стоит делить на этапы, лишний контекст чистить, а важные решения сохранять в файлах проекта.

## Что Anthropic объяснила о цене длинной сессии Claude Code?

14 августа 2026 года Anthropic объяснила, как устроен claude code workflow и почему Claude Code повторно отправляет модели весь накопленный контекст: содержимое прочитанных файлов, вывод команд и предыдущие сообщения. Prompt cache снижает цену повторной обработки, но не убирает расход. Длинная сессия поэтому постепенно становится дороже, особенно когда в ней остаются лишние поиски, тесты и отвергнутые идеи.

Статья Anthropic называется *Maximizing the value of your Claude Code sessions*. В ней разбирается экономика уже запущенной сессии Claude Code.

Claude Code использует накопленную историю как контекст текущего разговора. На каждом новом ходе накопленная история снова отправляется модели. В неё попадают:

- системные инструкции;
- содержимое `CLAUDE.md`;
- прочитанные файлы;
- результаты команд;
- предыдущие сообщения;
- вывод тестов и сборки.

Anthropic формулирует это прямо:

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

Кэш хранит состояние, чтобы сервер не вычислял его заново, но контекст всё равно занимает место и участвует в расчёте.

Есть и другая причина лишнего расхода. Расплывчатая задача заставляет Claude искать больше. Запрос «тесты падают» оставляет агенту широкий поиск. Более точный запрос «исправь падающий тест в `utils.test.ts`» задаёт конкретную точку входа. Claude меньше ходит по проекту, меньше читает и меньше добавляет в историю.

Практический вывод для сборщика простой: разговор не стоит продолжать только потому, что он уже открыт. Сначала спроси себя, нужна ли следующему шагу вся накопленная история. Если нет, используй `/clear`, новую сессию или отдельного subagent.

## Как выстроить рабочий процесс в Claude Code?

claude code workflow начинается с разделения работы по смыслу. Не проводи весь проект через один разговор. После обычного шага можно продолжить текущую сессию, откатить изменения через `/rewind`, очистить контекст командой `/clear`, сжать историю через `/compact` или передать шумную часть subagent. Новую задачу обычно выгоднее начинать с чистого контекста.

![Кот одобрительно смотрит на карточки с вариантами управления сессией.](https://s3.regru.cloud/crossmark/statejnik/images/guides/maximizing-the-value-of-your-claude-code-sessions/kadr-1.webp)

После каждого завершённого шага у Claude Code есть пять нормальных вариантов. Anthropic перечисляет их в материале о сессиях и контексте:

1. Продолжить текущую сессию, если следующий шаг использует ту же историю и те же решения.
2. Выполнить `/rewind`, если нужно вернуться к состоянию до неудачной правки.
3. Начать новую сессию через `/clear`, если текущая задача закончена или контекст стал лишним.
4. Сжать разговор через `/compact`, если работа продолжается, но вся история уже не нужна.
5. Передать отдельную работу subagent, если она объёмная, шумная или достаточно самостоятельная.

Я бы строил процесс вокруг этапов. Например:

1. Сначала попроси Claude изучить задачу и составить план.
2. Затем отдельно реализуй один небольшой блок.
3. После реализации запусти проверку и разберись с ошибками.
4. Когда блок готов, зафиксируй решения в файле проекта.
5. Для следующего независимого блока начни новую сессию.

Команда `/clear` очищает текущий разговор, а прошлая сессия остаётся доступной через `/resume`. Поэтому очистка контекста не равна потере работы.

`/compact` подходит для продолжения той же задачи. Например, Claude уже изменил несколько файлов, впереди проверка, а ранняя переписка занимает большую часть окна. Сжатие оставит резюме и позволит продолжить работу.

`/resume` нужен, когда ты возвращаешься к конкретному разговору. В терминале можно продолжить последнюю сессию командой:

```bash
claude --continue
```

Для выбора конкретной сессии используется:

```bash
claude --resume
```

Если задача связана с предыдущим обсуждением, но старый разговор уже не нужен целиком, я бы не тащил его автоматически. Сохрани итог в файл и начни чистую сессию. Так Claude получит актуальный статус, ограничения и решения без истории всех попыток.

Есть простой шаблон запроса для завершения этапа:

У Anthropic нет официальной универсальной схемы handoff-файла. Это заготовка для практического применения. Важно другое: состояние должно жить в проекте и быть доступным за пределами длинного окна чата.

## Сколько стоит лишний контекст в сессии?

В модели Anthropic выходные токены стоят примерно в пять раз дороже входных. Чтение из prompt cache обходится в 0,1 обычной цены входа, запись может стоить до 2x. Но даже дешёвый повтор участвует в каждом ходе. В разобранном примере пять запросов для одного небольшого исправления каждый содержал всю накопленную историю.

![Мужчина закрывает лицо рядом со схемой повторяющегося контекста и расходов.](https://s3.regru.cloud/crossmark/statejnik/images/guides/maximizing-the-value-of-your-claude-code-sessions/kadr-2.webp)

Цена складывается из нескольких разных действий, разобранных в [таблице контроля расходов Claude Code](/guides/tokeny-limity-i-schet-tablica-kontrolya-rashodov-claude-code).

| Что происходит | Относительная цена |
|---|---:|
| Обычный входной токен | 1x |
| Чтение токена из prompt cache | 0,1x |
| Запись токена в prompt cache | до 2x |
| Выходной токен | примерно 5x входного |

Anthropic объясняет дорогой вывод так:

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

Кэш помогает, пока совпадает начало запроса. Смена модели или уровня effort может нарушить совпадение и заставить систему заново обработать накопленный контекст. Долгая пауза тоже имеет значение: для подписки кэш живёт без нового хода один час, для API-ключа по умолчанию пять минут.

В примере Anthropic Claude делает пять запросов для одного небольшого исправления теста. Каждый из пяти содержит всю историю до текущего момента. Один запрос может выглядеть недорогим. Пять повторов уже дают другой результат.

Вывод команд тоже остаётся частью сессии. Тест-раннер, который печатает 400 успешных тестов построчно, добавляет эти 400 строк в каждый последующий ход. Если вывод превышает 30 000 символов, Claude Code записывает его в файл и оставляет в разговоре короткое превью с путём. До этого порога длинный вывод может продолжать тянуться за сессией.

В статье Anthropic есть ещё одна наглядная деталь: 40-й ход перечитывает 39 предыдущих ходов. Поэтому одна длинная сессия может стоить больше, чем та же работа, разделённая на несколько коротких.

Практический порядок экономии выглядит так:

1. Выбирай модель и effort до начала длинной работы.
2. Не оставляй в разговоре успешный шумный вывод, если достаточно короткого результата.
3. Не отправляй пять расплывчатых запросов вместо одного точного.
4. После завершения этапа очищай контекст.
5. Для самостоятельного исследования используй subagent.

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

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

## Почему `/compact` может вернуть уже отвергнутую идею?

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

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

Практик BSWEN описал это так:

Claude Code резко теряет контекст после сжатия.

Рабочая цепочка выглядит так:

1. Claude предлагает архитектуру A.
2. Ты проверяешь её и находишь ограничение.
3. Выбираешь архитектуру B.
4. Claude пишет код под B.
5. Проходит `/compact`.
6. В следующем этапе Claude видит код, но не помнит, почему A была отвергнута.
7. Он снова предлагает A.

Код никуда не исчез. Потерялось происхождение решения. Это самая неприятная часть, знакомая по [разбору потери контекста в Claude Code](/guides/kontekst-v-claude-code-zabyvaet-proekt): модель может выглядеть уверенно, потому что вариант A сам по себе кажется разумным.

Пользователь Reddit сформулировал разницу коротко:

Код лежит в репозитории, и модель может перечитать его; причина, по которой код написан именно так, живёт только в разговоре.

Поэтому перед `/compact` сохраняй три вещи вместо пересказа всех сообщений:

- принятое решение;
- отвергнутые варианты;
- причину отказа.

Подойдёт `DECISIONS.md`, короткий `HANDOFF.md` или запись рядом с кодом. Причину важно сохранить доступной после сжатия.

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

Для завершённого этапа сохраняй состояние и выполняй `/clear`. Если этап продолжается, но история стала слишком большой, сначала зафиксируй важное, а потом сжимай.

## Как сделать рабочий процесс в Claude Code динамичным?

claude code dynamic workflows строится на разделении контекста по сроку жизни. Постоянные правила лежат в `CLAUDE.md`, подробные процедуры загружаются через skills, обязательные механические действия выполняют hooks, а шумные самостоятельные исследования уходят в subagents. Так основная сессия получает нужный результат без всего промежуточного журнала.

Не складывай все инструкции в один файл. У разных правил разная частота использования.

`CLAUDE.md` нужен для постоянного контракта проекта:

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

Skill подходит для сценария, который нужен иногда. Например, отдельный skill может описывать выпуск релиза, проверку доступности, подготовку миграции или разбор большого набора файлов.

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

Subagent нужен для самостоятельной шумной работы:

- изучить большой репозиторий;
- собрать список вариантов;
- проверить несколько файлов;
- провести отдельный review;
- вернуть только вывод.

Отдельные subagents не наследуют контекст основной сессии и возвращают только результат. Это требует собственных ресурсов: subagent делает отдельные ходы и может перечитать то, что главная сессия уже знает. Зато промежуточный шум не разрастается в основном разговоре.

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

1. Постоянное правило загружается всегда.
2. Процедура подключается по задаче.
3. Механическое действие запускается hook.
4. Исследование выполняется в отдельном контексте.
5. В главную сессию возвращается короткий результат.

## Что держать в `CLAUDE.md`, а что вынести в skills?

`CLAUDE.md` загружается в начале сессии и расходует контекст, поэтому держи там только правила, которые нужны почти всегда. Подробные сценарии переноси в skills. Короткий файл с понятными ограничениями работает лучше длинного регламента, который приходится учитывать даже при простой правке одной кнопки.

Документация Anthropic перечисляет расположения файлов:

- `./CLAUDE.md`;
- `./.claude/CLAUDE.md`;
- `~/.claude/CLAUDE.md` для общих пользовательских правил.

Проектный файл загружается в начале сессии. Вложенные инструкции подгружаются, когда Claude читает файлы из соответствующего подкаталога.

В `CLAUDE.md` я бы оставил только то, что нельзя забыть:

```markdown
# Project rules

- Run `npm test -- --runInBand` after changes to application logic.
- Do not edit files in `data/backups/`.
- Keep API responses backward-compatible.
- The project uses TypeScript and ESLint.
- Record non-obvious architecture decisions in `DECISIONS.md`.
```

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

Подробную процедуру лучше вынести в skill:

```text
.claude/
  skills/
    release-check/
      SKILL.md
```

Внутри `SKILL.md` можно держать порядок проверки, дополнительные файлы, команды и условия запуска. Такой материал не обязан занимать контекст каждой новой сессии.

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

Разделяй также инструкции и автоматические действия. `CLAUDE.md` сообщает правило. Skill объясняет процедуру. Hook выполняет механическое действие. Если в файле написано «после каждого изменения запускай форматирование», это пожелание модели. Hook превращает его в автоматический запуск.

Важное ограничение: `CLAUDE.md` не даёт гарантии строгого исполнения каждой строки. Документация описывает содержимое файла как контекст для модели. Если действие должно произойти в определённый момент, его лучше оформить hook.

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

Обычный subagent подходит для самостоятельного и шумного исследования: он получает собственный контекст и возвращает в основную сессию итог. Fork подходит, когда нужно сохранить историю текущего разговора, но не засорять её промежуточными действиями. Для независимой задачи выбирай subagent, для параллельной проверки с общей историей - fork.

Обычный subagent начинает с отдельного контекста, как в [read-only-сценарии субагента в Claude Code](/guides/subagenty-odin-pomoshchnik-dlya-otdelnoy-zadachi-v-claude-code). Главная сессия передаёт ему запрос, а обратно получает результат. История основного разговора не копируется целиком.

Это удобно, когда нужно:

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

Fork работает иначе. Он наследует историю текущей сессии, поэтому ему требуется минимальное повторное объяснение уже обсуждённой задачи. При этом промежуточный вывод fork не засоряет основной контекст.

Документация Claude Code определяет fork так:

Fork - это subagent, который наследует весь разговор до текущего момента, а не начинает с чистого контекста.

Выбор можно свести к двум вопросам:

1. Нужна ли subagent вся история текущего разговора?
2. Может ли он выполнить работу самостоятельно и вернуть короткий вывод?

Если история не нужна, бери обычный subagent. Если без неё потеряется условие или уже принятое решение, используй fork.

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

## Как не потерять работу между сессиями?

`/clear` очищает текущий контекст, `/compact` заменяет историю резюме, `/resume` возвращает прошлую сессию, а `/export` сохраняет разговор в текстовом виде. Локальные транскрипты Claude Code хранятся в JSONL. Для решений и статуса проекта надёжнее использовать отдельные файлы, потому что старый чат не заменяет журнал работы.

Команды решают разные задачи:

| Команда | Что происходит |
|---|---|
| `/clear` | Текущий контекст очищается, старая сессия остаётся доступной |
| `/compact` | История заменяется сжатым резюме, работа продолжается |
| `/resume` | Открывается предыдущая сессия |
| `/export` | Разговор сохраняется в текстовом виде |
| `/context` | Показывается состав занятого контекста |

Транскрипты сессий хранятся локально в формате JSONL, а [передачу задачи между сессиями](/guides/claude-code-peredacha-zadachi-mezhdu-sessiyami-bez-poteri-konteksta) я разбирал отдельно. Это помогает восстановить разговор, но не превращает чат в удобную документацию проекта.

Перед очисткой можно переименовать сессию через `/rename`. Это пригодится, если к ней понадобится вернуться. Для продолжения последнего разговора после перезапуска есть `claude --continue`, для выбора конкретного - `claude --resume`.

Я бы разделял два типа сохранения.

**Сохранение разговора:**

- `/export`;
- локальный JSONL-транскрипт;
- `/resume`.

**Сохранение рабочего состояния:**

- `HANDOFF.md`;
- `DECISIONS.md`;
- список незавершённых действий;
- коммит с понятным сообщением;
- тест, который фиксирует принятое поведение.

Второй тип важнее для следующего этапа. Для следующего этапа вместо разговора на 200 сообщений нужны четыре ответа:

- что сделано;
- что сломано;
- что нельзя менять;
- с чего продолжать.

Не полагайся на то, что новая сессия сама найдёт старый план. Если нужен конкретный файл, укажи его явно:

## Как проверить Claude Code перед следующей задачей?

Перед работой запусти Claude Code из корня проекта, проверь рабочую папку, через `/memory` убедись в загрузке нужного `CLAUDE.md`, через `/context` посмотри состав контекста, а через `/mcp` проверь подключённые серверы. Такая проверка занимает несколько команд и ловит неверный каталог, пропущенные инструкции и неработающий MCP до первой правки.

![Собака поднимает лапу возле чек-листа проверки Claude Code перед работой.](https://s3.regru.cloud/crossmark/statejnik/images/guides/maximizing-the-value-of-your-claude-code-sessions/kadr-3.webp)

Открой терминал в папке, где лежат исходники и проектный `CLAUDE.md`. Не начинай с родительской директории и не надейся, что Claude сам выберет правильную папку.

Проверь путь до запуска:

   ```bash
   pwd
   claude
   ```

В начале сессии отправь короткий запрос:

   

Если Claude пытается запускать тесты или искать файлы в другом месте, останови работу и исправь расположение сессии. Для сохранения исходной папки после Bash-команд можно использовать переменную `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1`.

Файл проекта должен лежать в `./CLAUDE.md` или `./.claude/CLAUDE.md`. Общие пользовательские инструкции лежат в `~/.claude/CLAUDE.md`.

Выполни:

   ```text
   /memory
   ```

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

Сначала выполни:

   ```text
   /context
   ```

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

   ```text
   /mcp
   ```

Убедись, что нужный MCP-сервер подключён и показывает доступные tools. Настройка MCP в Claude Desktop сама по себе не означает, что сервер появился в Claude Code.

Если MCP не нужен для задачи, отключи лишние серверы. Anthropic отдельно советует проверять состав контекста через `/context` и ненужные MCP через `/mcp`.

Проверка перед задачей должна закончиться ясным состоянием: правильная папка, нужный `CLAUDE.md`, понятный контекст, ожидаемый MCP. Только после этого отдавай Claude задачу на изменение файлов.

## Вопросы и ответы

Правильный claude code workflow даёт больше результата за счёт распределения работы между сессиями. Чистый контекст нужен для новой задачи, сжатие - для продолжения текущей, subagent - для шумного исследования. Постоянные правила и решения лучше хранить в файлах проекта, чтобы они переживали очистку и сжатие.

Разделяй работу на этапы. Для новой задачи запускай чистую сессию через `/clear`. Продолжение выполняй через `/compact` или `/resume`, а шумное исследование отдавай subagent. Постоянные ограничения храни в `CLAUDE.md`, подробные процедуры - в skills.

Динамичный процесс подгружает инструкции по необходимости. `CLAUDE.md` содержит постоянные правила, skills описывают отдельные процедуры, hooks запускают обязательные механические действия, а subagents изолируют самостоятельную работу и возвращают только итог.

Начинай из корня проекта, проверяй `/memory` и `/context`, не смешивай независимые задачи, указывай файлы через `@`, заранее выбирай модель и effort для длинной сессии, важные решения сохраняй в `DECISIONS.md` или `HANDOFF.md`.

Ставь одну конкретную цель на сессию. Перед запросом проверь рабочую папку и инструкции. После завершения этапа сохрани статус, очисти контекст для новой задачи или возобнови нужную старую сессию через `/resume`.

Для новой задачи запускай `/clear`, когда старая история больше не нужна. При продолжении текущей работы используй `/compact`, если подробная переписка уже мешает. Перед сжатием сохрани решения и ограничения в файле проекта.

Нет. Историю можно возобновить через `/resume`, экспортировать через `/export` или найти в локальном JSONL-транскрипте. Но решения, текущий статус и причины отказа от вариантов лучше хранить в файлах проекта.

- [Maximizing the value of your Claude Code sessions | Claude by Anthropic](https://claude.com/blog/maximizing-the-value-of-your-claude-code-sessions)
- [Using Claude Code: session management and 1M context | Claude by Anthropic](https://claude.com/blog/using-claude-code-session-management-and-1m-context)
- [CLI reference | Claude Code Docs](https://code.claude.com/docs/en/cli-usage)
- [Manage sessions | Claude Code Docs](https://code.claude.com/docs/en/sessions)
- [How Claude remembers your project | Claude Code Docs](https://docs.anthropic.com/en/docs/claude-code/memory)
- [Common workflows | Claude Code Docs](https://docs.anthropic.com/en/docs/claude-code/common-workflows)
- [Create custom subagents | Claude Code Docs](https://docs.anthropic.com/en/docs/claude-code/sub-agents)
- [Why Claude Loses Context After Compaction | BSWEN](https://docs.bswen.com/blog/2026-02-09-claude-context-loss-compaction/)
- [What Actually Happens When You Run `/compact` in Claude Code](https://dev.to/rigby_/what-actually-happens-when-you-run-compact-in-claude-code-3kl9)
- [The failure mode I keep hitting in long Claude Code sessions](https://www.reddit.com/r/ClaudeAI/comments/1tglril/the_failure_mode_i_keep_hitting_in_long_claude_code_sessions/)
- [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp)