Сейф для проекта: git

1. Команды git зубрить не нужно

— Лёх, — Тёма машет блокнотом. — Дед мне тут восемь команд надиктовал, с флагами. Говорит, наизусть. Я это в жизни не упомню — git reset --hard, git checkout -b, где какой флаг… У меня от одного вида голова пухнет.

— А давай посмотрим, кто их вообще должен вводить, — Лёха хмыкает, впервые за день почти весело. — Дед прав про модель — золото тебе дал. А вот про «наизусть» — это он по своей молодости говорит, тогда иначе было нельзя. Тебе зубрить не надо. Открой агента и попроси словами: «заведи для проекта сейф». Просто словами. Не команду — просьбу.

Тёма пробует. Пишет в чат человеческое «заведи в проекте git, чтобы можно было откатываться». И агент сам, в терминале, выполняет ровно то, что Олег набивал руками:

● git init
  Initialized empty Git repository in /portal/.git/

— Вот и всё, сейф заведён, — говорит Лёха. — Та же команда, что дед пальцем набивал. Только он — из головы, а ты — словами. Заметь: git init набрал агент, не ты. Ты сказал, что хочешь, — он перевёл в команду.

Тёма косится на строчку в терминале:

— То есть весь блокнот деда я могу… не учить?

— Не будешь. — Лёха мотает головой. — Все эти команды выполняет сам ИИ-агент через терминал. Никаких отдельных «git-кнопок» в Claude Code нет: git для него — обычный инструмент, как и всё, чем он у тебя в терминале орудует. Тебе надо знать модель — main, ветка, точка, откат, — а перевести её в команды попросишь словами. Дедов синтаксис с флагами — его забота, не твоя.

Тёма заметно выдыхает. Самое страшное — что придётся зубрить блокнот с флагами — отвалилось.

— Но модель-то деда держи крепко, — добавляет Лёха. — Просьба словами работает только если ты понимаешь, ЧТО просишь. Скажешь мутно — агент и наберёт мутно. Дед тебе дал понимание, я даю удобство. Вместе — сила.

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

2. Боевой проход: ветка → правка → откат, main цел

— Ну а теперь, — подгоняет Лёха, — защитим твою правку reward-flow по-взрослому, по шагам. Всё, что ты дописал в бланк, сейчас станет настоящими действиями. И заметь разницу с дедом: он команды набивал сам, а ты — говоришь словами, команду под капотом выполняет агент.

Шаг 1. Изолируем работу в ветке — чтобы main остался нетронутым. Тёма пишет агенту словами:

Перед задачей создай ветку fix-reward и работай в ней, main не трогай.

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

● git checkout -b fix-reward
  Switched to a new branch 'fix-reward'

— Всё, — комментирует Лёха. — Терминал так и написал: «переключился на новую ветку fix-reward». Теперь агент возится в ней. Что бы он там ни наворотил — твой рабочий main стоит в стороне и даже не в курсе.

Шаг 2. Даём правку — и смотрим, что агент изменил, ДО принятия/коммита. Агент наменял в reward-flow. Но прежде чем сказать «принято», Тёма открывает просмотр изменений:

/diff

На экране — построчная картина правки. Зелёным то, что агент добавил, красным то, что убрал:

  reward-flow.js
+   const reward = base * multiplier;    // строки, которые агент добавил
-   const reward = base;
  leaderboard.js
+   sortByScore(players);                // ← а это он трогать был не должен

Тёма всматривается — и хмурится.

— Слушай, а чего он тут… он же не только начисление тронул. Вот это, в leaderboard.js, — оно откуда? Я про лидерборд ни слова не говорил.

— Ну вот за этим и смотрят, — кивает Лёха. — Заход кривой: агент зацепил соседнюю зону. Хорошо, что глянул ДО, а не принял вслепую. Кстати, эти же правки видно и прямо в открытом файле в редакторе — там, где агент менял, строки подсвечены так же. Дифф и файл показывают одно и то же, смотри где удобнее.

Шаг 3. Откатываем ветку к чистой точке — кривое исчезает. Тёма не лезет вычищать leaderboard.js руками. Раз заход кривой — просит сбросить ветку целиком:

Сбрось ветку к последней зафиксированной точке, начнём заново.

Агент переводит это в команду отката:

● git reset --hard HEAD
  HEAD is now at a1b2c3d рабочий портал до правок

Терминал подтвердил: ветка вернулась на ту самую точку, которую вы зафиксировали в начале. Весь кривой заход — и правильное начисление, и лишний хвост в лидерборде — стёрт разом, как не было.

Шаг 4. Чистовой заход — и фиксируем точку возврата. Теперь Тёма даёт правку заново, по более жёсткому ТЗ («трогать только начисление, соседнее не касаться»). На этот раз /diff показывает только reward-flow.js, ничего лишнего. Тёма принимает и просит зафиксировать точку:

Зафиксируй правку: начисление в reward-flow.

● git commit -m "fix: начисление в reward-flow"
  [fix-reward e4f5g6h] fix: начисление в reward-flow

— И заметь главное, — Лёха подбивает итог. — Всё это время твой main был нетронут. Ты сломал в ветке, откатил ветку, переделал, поставил точку — и рабочий портал ни разу не пострадал. Вот оно, «сломал → откатил → как не было». Только теперь не на уровне разговора, а на уровне самого репозитория. Глубже. Надёжнее.

3. Те же команды простыми словами

— Погоди, — Тёма листает назад по терминалу. — Я смотрю, я за весь проход ни одной команды из блокнота сам не набрал. Я говорил словами, а Олеговы checkout да reset появлялись сами.

— Вот это и есть главный навык работы с ИИ, — Лёха оживляется. — Не команды. Как попросить. У деда в блокноте — левая колонка в твоей голове: main, ветка, точка, откат. А правую колонку, синтаксис с флагами, теперь держит агент. Давай перепишу дедов блокнот на человеческий — чтоб у тебя было под рукой.

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

• Завести сейф (один раз на проект): «заведи в проекте git» → агент делает git init.
• Зафиксировать точку возврата: «зафиксируй текущее состояние» или «сохрани точку, тут всё работает» → агент делает git commit.
• Увести работу в сторону: «создай ветку под эту правку, main не трогай» → агент делает git checkout -b.
• Посмотреть, что наменял, до принятия: тут даже проще — у Claude Code своя команда /diff, наберёшь сам. Это тот же дедов git diff, только под рукой в сессии, интерактивный.
• Откатить кривой заход целиком: «сбрось ветку к последней зафиксированной точке» → агент делает git reset --hard.

— Заметь закономерность, — говорит Лёха. — Слева — что ты хочешь по модели. Справа — команда, которую ты знать наизусть не обязан. Твоя половина — левая. Ты формулируешь намерение, а перевод в синтаксис — забота агента. Чем точнее скажешь, что хочешь, тем меньше он напутает.

— То есть если я скажу мутно — он и сделает мутно, — ловит Тёма.

— Именно. «Слушай, ну сделай там с ветками нормально» — плохая просьба, агент угадывает. «Создай ветку fix-reward, работай только в ней» — хорошая, тут гадать нечего. Тот же самый навык, что ты качал с ТЗ: сказал внятно — получил внятное.

4. Зачем именно дифф, если main и так защищён

— А вот этот дифф, — Тёма не унимается. — Я ж теперь в ветке, main защищён. Может, и смотреть не надо? Накосячит — откачу, делов-то.

— Можно и так, — Лёха не спорит сразу. — Но смотри, в чём разница. Откат — это уже после того, как накосячил. А дифф — это до того, как принял. Это твой первый барьер между «агент предложил» и «попало в проект». Привычка простая: прежде чем сказать «ок, принимаю» — глянь, что именно он изменил. Что добавил, что выкинул.

Он чуть надавливает:

— Ты сам только что в боевом проходе на чём споткнулся? На том, что агент тронул лишнее. Если б ты принял вслепую — это лишнее уехало бы в ветку, потом, может, и в main. А ты глянул дифф — и поймал. Откат тебя спасает от записанного. А дифф ловит ещё до записи. Это разные моменты.

— То есть это меня отучает кивать «делай» не глядя.

— Именно так. И смотреть — это не «пробежать глазами для галочки». — Лёха возвращается к тому диффу. — Дифф показывает тебе ровно две вещи: что агент добавил и что убрал. Зелёное и красное, строка за строкой. Твоя задача на этом этапе — не оценивать, хорош ли код (это Санина забота), а всего лишь сверить: всё, что он тронул, — из твоей задачи? Ты просил починить начисление. Значит, в диффе должно быть только начисление. Появилось что-то ещё, из другого файла, из другой зоны, — вот он, звоночек.

— Как с тем лидербордом, — кивает Тёма. — Я про него не просил, а он в диффе всплыл.

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

Он делает акцент:

— Пока — только это: посмотреть, что меняется, и поймать чужое. Глубокий разбор — «а это лишнее, а это опасное, а это агент по-тихому переписал» — будет позже, отдельно. Сейчас базовый рефлекс простой: не принимай код, не посмотрев, из твоей ли он задачи.

5. Почему /rewind не спас той ночью

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

— Слушай, так а почему та ночь-то рухнула? У меня же был /rewind. Я по нему ударил — а он не спас. Теперь у меня git. А в чём разница-то между ними? Это же оба «откат».

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

— Первая — дифф. Ловит ошибку ДО того как код вошёл в проект. Барьер на входе.

— Вторая — /rewind. Откатывает внутри сессии, прямо в живом разговоре. Пока ты тут, болтаешь с агентом, — он отматывает назад правки текущего захода.

— Третья — git. Возвращает уже записанное на диск. Ветка, коммит — самый глубокий этаж. Работает, даже когда разговор кончился и агент вообще ничего не помнит.

Он останавливается на главном:

— А теперь смотри, что было той ночью. Сессия отработала, ноут уснул, разговор закрылся. Правки давно легли на диск. И ты бьёшь по /rewind — по сетке, которая живёт в сессии. А сессии уже нет, отматывать нечего. Кнопка не дотянулась до диска не потому, что плохая. Она просто с другого этажа. Она никогда и не должна была тащить назад весь репозиторий — для этого есть git, нижний этаж. А git той ночью у тебя был не построен.

Тёма молчит. Спасательный круг с дырой из третьего уровня встаёт на место окончательно. Дыра — это не поломка круга. Это то, что кругом нельзя сделать работу якоря. Разные вещи, разные этажи.

— То есть мне нужны все три, — медленно говорит он. — Не одна. Дифф — на входе, rewind — в разговоре, git — на диске.

— Все три. Каждая на своём этаже. Той ночью у тебя был только средний, а провалился ты на нижний, где было пусто.

6. Честная пометка, чтоб не было сюрпризов

— И одна честная мелочь напоследок, — Лёха не даёт уйти в сказку. — Про безопасность отката. git reset --hard — команда с характером: сносит незафиксированное без спроса. И знай сразу: волшебного «git-предохранителя», который сам поймает тебя за руку именно на ней, в Claude Code нет — не надейся на него. Держит тебя другое, то, что ты уже знаешь: обычный переспрос перед действием агента. Прежде чем выполнить в терминале что-то разрушительное, агент в обычном режиме спрашивает разрешение — точно так же, как на правки файлов. Вот этот переспрос и есть твоя страховка: увидел git reset --hard в запросе на подтверждение — притормози на секунду и подумай, точно ли сбрасываешь то, что не жалко. Отдельной git-няньки сверху нет, есть ты и твоё «разрешаю».

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

Тёма подводит итог сам:

— Короче. Сейф — это git. Ветка, чтоб агент возился в стороне от рабочего. Дифф, чтоб глянуть до принятия. Коммит — честная точка на диске. Откат — вернуть ветку к точке, как не было. И всё это делает агент, я только говорю словами. Три сетки на трёх этажах, нужны все.

— Вот теперь, — подытоживает Лёха, — можно пускать агента в reward-flow по-настоящему. Сейф собран.