Чекпоинты (Checkpoints): страховочная сетка с возможностью отката

📚 Навигация по серии: Предыдущая статья 36 Слеш-команды помогла разобраться с длинным списком команд, начинающихся с /, среди которых упоминалась и /rewind. Эта статья посвящена детальному разбору этой темы — чекпоинты (Checkpoints) представляют собой автоматически создаваемые Claude Code «снимки состояния кода перед редактированием», позволяющие в любой момент откатиться назад. Как они создаются, как выполнять откат, что подлежит восстановлению, а что нет, и как разделяются обязанности с git — разберем в этой статье.

Говорят, чекпоинты — это ваша «таблетка от сожалений», с которой можно спокойно разрешить Claude масштабные изменения. Но честно говоря, если относиться к ним как к git, вы рано или поздно окажетесь у разбитого корыта.

Представьте разработчика, который только начал использовать Claude Code. Услышав о существовании команды /rewind, он расслабился и позволил Claude изменить сразу десяток файлов, попутно выполнив несколько команд rm и mv для очистки папок. На третьем шаге выяснилось, что изменения пошли не в ту сторону. Разработчик спокойно вводит /rewind для отката — и обнаруживает, что хотя часть кода вернулась, удаленные через rm файлы исчезли насовсем. Шок и непонимание: «Нам же обещали полную отмену?»

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

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

Прочитав эту статью, вы получите:

• Простое объяснение того, что такое чекпоинты и в какие моменты они создаются автоматически (без вашего участия).
• Два способа вызова: через /rewind и двойное нажатие Esc при пустом поле ввода, а также разбор вариантов в меню отката.
• Таблицу «что можно восстановить vs что восстановить нельзя» (код и диалоги восстанавливаются, побочные эффекты bash и внешние состояния — нет).
• Четкое разделение задач между чекпоинтами и git: в каких случаях использовать каждый инструмент и почему один не заменяет другой.
• Практическое упражнение с пошаговым разбором: искусственно создадим ошибку в коде и откатимся назад.

---

01 Что такое чекпоинты: незаметные снимки перед каждым вашим запросом

Начнем с главного: чекпоинт — это автоматически создаваемый Claude Code снимок состояния вашего кода перед внесением изменений. Он создается при каждом вашем запросе, а вернуться к любому снимку можно простой командой /rewind.

Вы уже сталкивались с этим понятием в статье 07 и знаете, что при ошибках можно использовать /rewind для подстраховки. Теперь разберем тему глубже. Вспомните ритм работы с Claude: вы даете команду → он думает, вызывает инструменты, меняет файлы → вы оцениваете результат и даете следующую команду (этот цикл описан в статье 03). Чекпоинт создается непосредственно перед началом выполнения каждой вашей команды, фиксируя текущее состояние кода.

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

Официальное описание механизма:

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

Ключевое слово здесь — автоматически. Это главное преимущество чекпоинтов и их основное отличие от git: вам не нужно делать ничего лишнего. Для сохранения в git необходимо помнить о вызове git commit, иначе прогресс не запишется; чекпоинты создаются Claude в фоновом режиме без вашего участия.

Разработчики выделяют четыре основных сценария использования чекпоинтов, подкрепим их примерами из практики:

• Поиск альтернативных решений: реализация варианта А не принесла результата, откатываемся к началу и пробуем вариант Б. Исходный код при этом не пострадает, можно не бояться сломать рабочее решение.
• Восстановление после ошибок: AI изменил файл, но тесты упали, а вырезать изменения вручную построчно лень. Откатываемся к предыдущему чекпоинту и получаем чистый рабочий код.
• Эксперименты с функционалом: поручаем Claude полностью переписать модуль для проверки гипотезы. Если результат окажется хуже оригинала — возвращаемся к моменту до переписывания, будто ничего и не было. Появляется смелость экспериментировать.
• Очистка контекста: в процессе отладки накопился длинный диалог, при этом исходные инструкции нужно оставить, а историю неудачных попыток — отбросить. Здесь поможет функция сжатия (описана в разделе 03).

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

💡 Резюме в одной фразе: Чекпоинт — это автоматический снимок кода перед началом редактирования, создаваемый при каждом вашем запросе. Вы можете в любой момент вернуть код и диалог к этой точке с помощью команды /rewind без необходимости ручного сохранения.

---

02 Правила создания: когда, где и сколько хранятся снимки

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

Момент создания: один чекпоинт на один запрос

Правило простое: каждый раз, когда вы отправляете новый запрос (prompt), Claude Code создает новый чекпоинт.

Каждый пользовательский запрос создает новый checkpoint.

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

Давайте схематично изобразим, как расставляются точки сохранения в процессе диалога:

На схеме показано: перед выполнением каждого запроса создается точка сохранения (синие узлы). Если на шаге 3 код сломался, команда /rewind позволяет по пунктирной линии вернуться к чекпоинту 1, отменив изменения запросов 2 и 3 вместе с историей переписки.

Место хранения: папка ~/.claude

Снимки состояния не просто висят в оперативной памяти, они записываются на диск. В описании структуры папок (claude-directory.md) указано:

file-history/<session>/ — снимки файлов до редактирования со стороны Claude, используемые для восстановления через checkpoint.

Каждая сессия сохраняет свои снимки в папке ~/.claude/file-history/<session>/. Вам не нужно редактировать её содержимое, но знание этого пути дает понимание двух вещей: во-первых, чекпоинты опираются на реальные файлы на диске, а во-вторых, при необходимости очистки места на диске вы будете знать, где хранятся эти временные файлы.

Сохранение между сессиями

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

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

Это означает следующее: если вы выйдете из программы через Ctrl+D сегодня, а завтра продолжите работу командой claude --resume (или --continue), все созданные ранее чекпоинты будут доступны для отката через /rewind. Иногда кажется, что откат работает только в рамках одного открытого окна консоли, но на самом деле при возобновлении даже трехдневного диалога вы сможете вернуться к его ранним этапам. Снимки привязаны к сессии и лежат на диске, пока не сработает лимит cleanupPeriodDays.

Срок хранения: 30 дней по умолчанию

Снимки не хранятся вечно, для них настроено автоматическое удаление:

Автоматическая очистка через 30 дней (настраивается).

За этот срок отвечает параметр cleanupPeriodDays в файле settings.json (мы разбирали структуру settings.json в статье 31). По умолчанию период очистки неактивных сессий равен 30 дням (минимум 1 день, значение 0 установить нельзя). Этот же период определяет и срок жизни чекпоинтов. Совет новичкам: не меняйте этот параметр. Значения по умолчанию вполне достаточно, а для долгосрочного хранения прогресса используйте git (подробнее в разделе 05), не возлагая эти задачи на чекпоинты.

Периодически заглядывая в папку ~/.claude, вы будете знать, что в папке file-history хранятся те самые файлы, которые позволяют вам безболезненно использовать /rewind. Всё это работает незаметно для пользователя.

Суммируем параметры чекпоинтов в таблице:

Параметр	Описание	Ваши действия
Момент создания	Автоматически перед каждым отправленным запросом	Не требуется дополнительных действий, пишите запросы как обычно
Место хранения	Папка ~/.claude/file-history/<session>/	Не требует ручного вмешательства
Сохранение при выходе	Доступно после перезапуска и возобновления сессии	Можно продолжить работу и использовать точки отката на следующий день
Срок жизни	30 дней по умолчанию (параметр cleanupPeriodDays)	Оставьте по умолчанию, долгосрочный прогресс фиксируйте в git

💡 Резюме в одной фразе: Чекпоинты создаются перед каждым запросом, сохраняются в папке ~/.claude/file-history/, доступны после перезапуска программы и автоматически удаляются через 30 дней по правилу cleanupPeriodDays. Процесс полностью автоматизирован.

---

03 Как выполнить откат: /rewind, двойной Esc и меню восстановления

Теперь разберем, как вызвать интерфейс отката. Для этого есть два пути: команда /rewind или двойное нажатие Esc при пустом поле ввода.

Два способа вызова

Первый способ — ввести слеш-команду в сессии:

/rewind

Второй способ — более быстрый: нажать клавишу Esc дважды при пустом поле ввода:

(поле ввода пустое, нажимаем Esc Esc)

Оба действия открывают интерактивное меню отката (rewind menu).

Запустите /rewind или дважды нажмите Esc при пустом поле ввода, чтобы открыть меню восстановления.

Здесь есть нюанс, о котором мы упоминали в статье 14:

Если в поле ввода есть текст, двойное нажатие Esc очистит его, а не откроет меню. Очищенный текст сохранится в историю ввода, его можно вернуть нажатием клавиши Up после работы с меню восстановления.

То есть, если в поле ввода есть текст, двойное нажатие Esc просто сотрет его. Для открытия меню поле ввода должно быть пустым. Это частая ошибка новичков: они начинают писать запрос, передумывают, нажимают Esc Esc, текст пропадает, а меню не открывается. Сначала очистите поле ввода, а затем нажимайте Esc Esc. Если сомневаетесь, просто введите /rewind — эта команда сработает в любом случае.

Варианты в меню отката

В открывшемся меню отобразится список отправленных вами запросов (точки сохранения). Сначала выберите «к какому запросу нужно вернуться», а затем укажите «как именно выполнить откат». Это важный шаг, так как варианты восстановления различаются.

Разберем доступные варианты действий:

Пункт меню	Что делает	Когда применять
Restore code and conversation	Возвращает в выбранную точку и код, и историю диалога	Когда нужно полностью переделать шаг, стерев неудачные реплики из истории
Restore conversation	Откатывает историю диалога, сохраняя текущий код на диске	Когда код написан верно, но диалог ушел в сторону и нужно продолжить обсуждение с чистого листа
Restore code	Откатывает изменения в файлах, сохраняя историю диалога	Когда код написан с ошибками и его нужно переписать, но вы не хотите терять контекст обсуждения
Summarize from here	Сжимает в краткое резюме выбранное сообщение и всё, что идет после него	Для удаления из контекста истории неудачных попыток с сохранением ключевых моментов
Summarize to here	Сжимает в краткое резюме всё обсуждение до выбранного сообщения	Для удаления истории долгих начальных обсуждений с сохранением деталей последних шагов
Never mind	Закрывает меню без выполнения действий	При случайном вызове меню

Зачем нужно разделение на частичный откат? Рассмотрим примеры:

• Вариант «Restore code» (только код): вы вели диалог с Claude в течение пяти шагов, пришли к решению, он изменил код, но программа не заработала. Вы хотите отменить правки в файлах, но сохранить историю обсуждения, чтобы не объяснять задачу заново. Вы выбираете «Restore code», файлы возвращаются к исходному состоянию, а история переписки сохраняется, позволяя попросить Claude переписать код с учетом ошибок.
• Вариант «Restore conversation» (только диалог): противоположная ситуация. Вы довольны измененным кодом, но в процессе обсуждения засыпали Claude вопросами на отвлеченные темы, и он начал путаться. Вы выбираете «Restore conversation», откатывая историю переписки до момента начала оффтопа, при этом код на диске остается измененным. Вы продолжаете работу с чистым контекстом.

Таким образом, откат кода и диалога — это два независимых рычага управления, которые можно использовать как вместе, так и по отдельности. Чаще всего используется откат только кода (Restore code): это позволяет быстро переписать неудачный фрагмент без потери контекста.

Важно понимать разницу между «восстановлением» (restore) и «сжатием» (summarize). Несмотря на то, что они находятся в одном меню, их функции принципиально отличаются:

• Восстановление (restore) — это физический откат состояния: отмена изменений в коде, истории диалога или обоих направлениях. Это «возврат во времени».
• Сжатие (summarize) — не меняет файлы на диске. Оно сжимает выбранную часть диалога в краткое резюме силами AI для освобождения контекста. Это «наведение порядка на столе», а не откат.

Описание этого различия в документации:

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

Сжатие работает аналогично команде /compact (описанной в статье 19), но позволяет действовать более гибко: вы можете выбрать конкретное сообщение и сжать переписку до или после него.

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

Удобная деталь: при выборе вариантов «Restore conversation» или «Summarize from here» исходный текст выбранного сообщения автоматически подставится в поле ввода, позволяя вам отредактировать его и отправить заново (вы получаете возможность переформулировать запрос). При выборе «Summarize to here» поле ввода останется пустым, и вы продолжите диалог с конца истории.

Возможные вопросы при работе с меню

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

«Я случайно откатился слишком далеко, можно ли вернуть изменения назад?» — без паники. Файлы чекпоинтов сохраняются на диске (как описано в разделе 02) и не удаляются при вызове /rewind. Вы можете снова вызвать меню восстановления и выбрать более позднюю точку. Тем не менее, поведение меню может отличаться в разных версиях программы, поэтому главное правило безопасности остается неизменным: перед выполнением сложных экспериментов всегда делайте git commit — история коммитов git является вашей главной гарантией сохранности кода (подробнее в следующем разделе).

💡 Резюме в одной фразе: Вызвать откат можно через /rewind или двойным нажатием Esc при пустом поле ввода. Выберите точку отката и вариант действия: «Restore» возвращает файлы и диалог назад во времени, а «Summarize» лишь сжимает историю переписки, не затрагивая код на диске.

---

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

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

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

Ограничения системы подробно описаны в документации, приведем их в виде наглядной таблицы:

Объект изменений	Восстанавливается через чекпоинт?	Причина
Содержимое файлов, измененное инструментами Claude	✅ Да	Это основная задача системы чекпоинтов
История диалога	✅ Да	Меню восстановления позволяет откатить переписку
Изменения файлов через bash-команды (rm, mv, cp и т.д.)	❌ Нет	Изменения в bash не отслеживаются системой
Файлы, не изменявшиеся в текущей сессии	❌ Нет	Отслеживаются только файлы, затронутые в текущем диалоге
Ручные изменения файлов вне Claude Code	❌ Нет	Внешние правки не фиксируются программой
Правки из параллельных сессий Claude Code	❌ Нет	Каждая сессия имеет изолированную историю
Внешние побочные эффекты (API-запросы, изменения БД, push в репозиторий)	❌ Нет	Внешнее окружение находится за рамками контроля программы

Особое внимание стоит обратить на первые два пункта в списке ограничений:

Система чекпоинтов не отслеживает изменения файлов, выполненные через bash-команды. Например, если Claude Code выполнит rm file.txt, mv old.txt new.txt, cp source.txt dest.txt и т.д., эти действия невозможно отменить через rewind. Восстановлению подлежат только изменения, внесенные непосредственно инструментами редактирования файлов Claude.

В этом и заключается ловушка: если Claude удалил файлы через команду rm, запущенную в bash, то /rewind не сможет их вернуть. Запомните: изменения файлов со стороны Claude делятся на два типа — через инструменты редактирования (отслеживаются чекпоинтами) и через bash-команды (не отслеживаются). Для вас результат выглядит одинаково (файлы изменились), но для системы чекпоинтов разница принципиальна.

Как понять, какой инструмент использовал Claude? Следите за именами вызываемых инструментов в процессе его работы (нажатие Ctrl+O позволяет развернуть подробный лог выполнения):

• Если вы видите вызовы Edit, Write, MultiEdit — это инструменты редактирования, изменения фиксируются чекпоинтами и могут быть отменены через /rewind.
• Если вы видите запуск Bash с командами вроде rm, mv, cp или перенаправлением вывода > — это bash-инструмент, такие изменения чекпоинтами не отслеживаются и восстановить их через /rewind не получится.

Эти вызовы наглядно отображаются в консоли. Возьмите за правило обращать внимание на используемые инструменты при выполнении опасных операций. Если вы видите, что запускаются bash-команды изменения файлов, подстрахуйте себя вызовом git commit перед началом работы.

Разберем ограничение на внешние правки:

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

Это означает, что правки, внесенные вами в VS Code или другой IDE в процессе диалога, чекпоинтами текущей сессии Claude зафиксированы не будут.

Простое практическое правило: если вы поручаете Claude операции по удалению файлов, переносу папок, изменению баз данных или отправке сетевых запросов — никогда не надейтесь на /rewind для отката изменений. Сделайте git commit или резервную копию базы данных перед запуском. Чекпоинты надежно работают только для отмены правок в коде, выполненных редактором Claude.

Давайте сравним ожидания новичков с реальностью:

Проблема	Поможет ли /rewind?	Реальность	Как исправить
Claude испортил код в файле при редактировании	✅	✅ Поможет	Вызвать /rewind
Claude случайно удалил файл через rm	✅	❌ Нет	Использовать git checkout или бэкап
Claude запустил скрипт, изменивший данные в БД	✅	❌ Нет	Восстановить БД из бэкапа или откатить транзакцию
Claude выполнил git push в удаленный репозиторий	✅	❌ Нет	Сделать git revert в Git
Вы сами изменили код в IDE и сломали файл	✅	❌ Нет	Использовать отмену в IDE или Git

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

💡 Резюме в одной фразе: Чекпоинты восстанавливают только код, измененный редактором Claude, и историю диалога. Побочные эффекты bash-команд (удаление через rm, перенос через mv), внешние правки и сетевые запросы восстановить невозможно — для таких задач используйте git и резервное копирование.

---

05 Разделение обязанностей с git: локальный откат vs постоянная история

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

Эту разницу лаконично описывает следующее правило:

Воспринимайте чекпоинты как инструмент локальной отмены изменений («Undo»), а Git — как постоянную историю проекта («History»).

Аналогия: черновик для набросков vs архив документов. Чекпоинты похожи на работу с черновиком: вы можете написать фрагмент, стереть его ластиком и написать заново. Это происходит быстро, просто, нужно только вам и теряет актуальность после завершения работы (через 30 дней папка очистится). Git похож на архив документов: вы распечатываете чистовой вариант, подписываете его и сдаете в архив на бессрочное хранение с возможностью совместного доступа. Вы же не отказываетесь от сдачи документов в архив на том основании, что у вас есть ластик для черновика? Используются оба инструмента.

Позиционирование инструментов в документации:

• Используйте системы контроля версий (например, Git) для фиксации коммитов, создания веток и ведения долгосрочной истории;
• Чекпоинты дополняют, но не заменяют полноценный контроль версий.

Сравним их возможности в таблице:

Параметр	Чекпоинты (Checkpoint)	Git
Кто инициирует сохранение	Автоматически (при каждом запросе)	Вручную (через git commit)
Частота точек сохранения	Частая (каждый шаг диалога)	Редкая (по решению разработчика)
Откат побочных эффектов bash	❌ Не поддерживается	✅ Поддерживается для зафиксированных файлов
Срок хранения данных	Временный (удаление по лимиту cleanupPeriodDays)	Постоянный (до ручного удаления истории)
Совместная работа	❌ Локально на вашей машине	✅ Доступно всей команде после отправки в репозиторий
Основное назначение	Быстрый откат неудачного шага в рамках сессии	Фиксация этапов работы, история проекта, командная разработка

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

Рекомендуемый рабочий процесс строится следующим образом:

• Для частых экспериментов и быстрых откатов используйте чекпоинты. Попробовали изменить функцию, не получилось — вызвали /rewind, попробовали иначе. Быстро и без засорения истории git.
• Для фиксации рабочих этапов используйте git commit. Реализовали фичу, прогнали тесты, всё работает — сделали коммит. Это ваш надежный рубеж обороны.
• Для защиты от ошибок в bash-командах полагайтесь на git. Чекпоинты не спасут при случайном вызове rm, но если вы регулярно делали коммиты, git восстановит состояние рабочей директории.

Оптимальный ритм: в процессе работы с Claude вы страхуетесь чекпоинтами для мелких откатов, а завершив логический этап — фиксируете результат через git commit. Такой подход сочетает удобство частых откатов и надежность постоянного архива. Типичная ошибка: полагаться только на чекпоинты, работать полдня без коммитов, а затем столкнуться с падением сессии. История чекпоинтов сотрется или прервется, и вы не сможете вернуться на три часа назад. Выработайте привычку делать коммиты после каждого успешного шага.

О том, как интегрировать git в рабочий процесс с Claude (создание коммитов силами AI, управление ветками), мы подробно поговорим в статье 43 «Git-воркфлоу». Сейчас главное запомнить: чекпоинты — это локальный Undo, git — постоянная история; они дополняют друг друга.

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

claude --continue --fork-session

Эта команда создаст копию текущего сеанса в новой ветке диалога, оставив оригинал без изменений. Подробнее об этом в статье 34.

💡 Резюме в одной фразе: Чекпоинт — это автоматический локальный откат (частый, временный, только для файлов проекта), а git — ручная постоянная история (надежная, долговечная, командная). Экспериментируйте с помощью чекпоинтов, фиксируйте вехи в git.

---

06 Практика: ломаем код и откатываем изменения

Закрепим полученные знания на практике. Мы пройдем минимальный цикл: позволим Claude изменить файл, решим отменить изменения и с помощью /rewind вернемся к исходной точке. Нам не понадобятся сложные проекты, достаточно пустой папки и терминала.

Шаг 1: Создаем тестовую папку и первый файл

Выполните команды в терминале:

mkdir ~/rewind-demo && cd ~/rewind-demo
git init
printf 'hello\n' > note.txt
git add note.txt && git commit -m "init: начальный файл"

Ожидаемый результат: создан файл note.txt с текстом hello, изменения зафиксированы в git (это позволит сравнить работу систем отката).

Шаг 2: Запускаем Claude и просим внести изменения

Запустите программу:

claude

Отправьте первый запрос (он создаст первую точку отката):

Измени содержимое файла note.txt: напиши три строки - apple, banana, cherry. Используй инструменты редактирования.

Ожидаемый результат: Claude с помощью инструмента редактирования запишет три строки в файл (в режиме default он сначала покажет diff и попросит подтверждения — подтвердите действие). Мы явно указали использовать инструменты редактирования, чтобы изменение попало под контроль чекпоинтов.

Шаг 3: Делаем еще одно изменение

Отправьте второй запрос:

Теперь удали эти три строки и напиши одну: "ненужная версия"

Ожидаемый результат: в файле note.txt осталась только строка ненужная версия. Мы сделали два запроса, на шкале времени появилось два чекпоинта.

Шаг 4: Вызываем меню отката

Убедитесь, что поле ввода пустое, и нажмите Esc дважды (или введите /rewind):

(поле ввода пустое, нажимаем Esc Esc)

Ожидаемый результат: откроется интерактивное меню со списком ваших запросов. Выберите точку перед первым изменением (запрос с фруктами) и укажите вариант «Restore code and conversation».

Шаг 5: Проверяем результат восстановления

Вернитесь в терминал (или выполните команду прямо в сессии через префикс !):

! cat note.txt

Ожидаемый результат: содержимое файла note.txt снова состоит из одной строки hello. Обе итерации изменений отменились, история диалога также вернулась к началу. Возврат строки hello подтверждает успешный откат. Это наглядный пример работы локальной отмены без использования команд git.

Шаг 6 (проверка ограничений): пробуем удалить файл через bash

Теперь проверим, как чекпоинты работают с побочными эффектами bash-команд. Отправьте запрос:

Удали файл note.txt с помощью bash-команды rm

После удаления попытайтесь вызвать /rewind, выбрать точку до удаления и нажать «Restore code». Проверьте содержимое папки:

! ls

Ожидаемый результат: файл note.txt не восстановился, в списке файлов его нет. Это подтверждает правило: изменения через bash-команды (rm) чекпоинтами не отслеживаются и вернуть их через /rewind нельзя. Восстановить файл в данном случае поможет только git:

git checkout note.txt

(Эта команда восстановит файл из коммита init).

Ожидаемый результат: файл note.txt со строкой hello снова на месте. Git заполнил пробел, который не смогли закрыть чекпоинты.

Пройдя эти шаги, вы наглядно увидели работу обеих систем: изменения редактора легко отменяются через /rewind (шаг 5), а для восстановления после bash-команд требуется git (шаг 6). Этот опыт поможет вам избежать ошибок в реальной работе.

💡 Резюме в одной фразе: На практике мы убедились: изменения, внесенные редактором Claude, легко откатываются через /rewind, в то время как удаление файлов через bash-команду rm требует использования git checkout для восстановления. Помните об этих границах.

---

07 Заключение

Мы разобрали систему автоматического сохранения и отката в Claude Code — как она работает, какие ограничения имеет и как взаимодействует с git.

Резюмируем ключевые выводы:

Вопрос	Ответ	Ключевая мысль
Что такое чекпоинт	Автоматический снимок кода перед изменением	Создается без вашего участия при каждом запросе
Как запустить откат	Ввести /rewind или нажать Esc Esc при пустом вводе	Двойное нажатие при наличии текста сотрет черновик, а не откроет меню
Что выбирать в меню	Выбрать точку восстановления и режим (код, диалог или всё вместе)	«Restore» откатывает состояние файлов/диалога, «Summarize» сжимает историю без изменения файлов
Что можно восстановить	Изменения файлов редактором Claude и историю диалога	Всё, что сделано стандартными инструментами записи
Что нельзя восстановить	Результаты bash-команд (rm, mv), ручные внешние правки	Любые изменения, произошедшие вне редактора Claude
Как работать с Git	Совмещать: чекпоинты для мелких откатов, Git для вех	Чекпоинты — это локальный Undo, Git — постоянный архив проекта

Теперь вы можете уверенно проводить любые эксперименты с кодом в сессии Claude Code: при ошибках вы всегда сможете сделать шаг назад с помощью /rewind или Esc Esc, выбрав нужную глубину отката (только код, только диалог или всё вместе). При этом вы помните об ограничениях чекпоинтов и будете вовремя фиксировать важные этапы работы в git, обеспечивая надежную защиту проекта.

---

В следующей статья 38 «Справочник по плагинам» мы подробно разберем внутреннее устройство плагинов. Мы уже изучили Skill, Hook, субагентов и MCP. Как объединить эти инструменты в один подключаемый модуль, которым можно поделиться с коллегами? Мы изучим структуру файлов плагина и назначение полей конфигурации, чтобы вы могли создавать свои расширения для Claude Code.

---

Рекомендуемое чтение

• Параллельные задачи: запуск нескольких агентов Claude одновременно
• Интеграция MCP: подключение внешних сервисов к Claude
• Работа в VS Code: интеграция с редактором