Вайб-кодинг с Claude Code: как ставить задачи и не ломать проект

Как ставить задачи, читать ответы, коммитить и откатываться. 4 принципа и дневная рутина, чтобы не ломать работающее и не терять контроль.

Зачем этот гайд

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

Большинство людей на этом этапе бросают. Не потому что тупые, не потому что Claude плохой. А потому что попадают в одну и ту же ловушку: накапливают «неясные правки», теряют контроль над тем, что изменилось, однажды утром обнаруживают, что вчера рабочий продукт сегодня не запускается — и не понимают, куда откатывать. Франкенштейн. Вся работа недели — в мусор.

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

Короче: хочешь вместо «неделю покодил — всё сломалось» получить «месяц покодил — у меня работающий продукт» — нужно поставить привычки. Их четыре.

4 главных принципа

Всё остальное в этом гайде — следствие этих четырёх. Если запомнишь только их — уже выиграл.

Принцип 1. Один шаг за раз

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

Правило: одна задача — одна проверка. Claude сделал X — ты открыл результат глазами, потыкал, убедился, что X работает. Только потом ставишь задачу Y. Не раньше.

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

Принцип 2. Говори КОНКРЕТНО

Claude не телепат. Слова «красивее», «удобнее», «лучше», «современнее» — это пустой звук. У Claude своё представление о красивом, у тебя — своё, совпадают они случайно.

Всегда переводи размытые оценки в конкретные единицы. Размеры — в пикселях. Цвета — в шестнадцатеричном коде (вроде #1a1a1a) или хотя бы словами («тёмно-серый, почти чёрный»). Позиции — «слева / справа / по центру / сверху / снизу». Количество — числом.

Плохо: «Сделай заголовок красивее». Хорошо: «Увеличь главный заголовок до 48 пикселей, сделай его жирным, добавь отступ снизу 24 пикселя».

Плохо: «Карточки продуктов выглядят неудобно». Хорошо: «Расположи карточки продуктов в три столбца на больших экранах и в один столбец на телефоне. Между карточками — отступ 16 пикселей. У каждой карточки — закруглённые углы 12 пикселей и тонкая серая граница».

Это не «программистский жаргон», это просто конкретика. Когда ты говоришь конкретными числами — ты получаешь то, что описал. Когда говоришь «удобнее» — ты получаешь случайность.

Принцип 3. Коммить часто

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

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

Правило: после каждого работающего шага — коммит. Буквально:

Сделай коммит с описанием «добавил раздел FAQ с тремя вопросами».

Claude сам запишет все изменения в историю. Если завтра что-то сломается — ты одной командой откатишься на вчерашнее рабочее состояние. Это твоя машина времени.

Частый вопрос: «а не много ли коммитов будет?» Нет. Чем больше — тем лучше. Коммит — бесплатный. А возможность откатиться на любой шаг назад — бесценна.

Принцип 4. Два промаха — СТОП, чистый старт

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

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

Правило: если Claude два раза подряд промахнулся на одной задаче — СТОП. Не пиши третье уточнение. Сделай три вещи:

Откатись к последнему рабочему коммиту (скажи Claude: «откатись к предыдущему коммиту — тому, где X ещё работал»).
Перечитай описание задачи, которое ты давал. Найди, где оно неконкретное.
Перепиши задачу заново — с большей конкретикой — и задай её заново, с чистого листа.

Три итерации на одной задаче — это не плохая работа Claude. Это сигнал, что твоя постановка нечёткая. Исправление всегда на уровне постановки, а не на уровне кривых правок.

Ежедневный рабочий цикл

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

Фаза 1: Планирование (5–15 минут, до открытия Claude Code)

Ты ещё не открыл Claude Code. Это важно. Планирование в голове перед запуском — то, что отличает «покодил час и получил результат» от «покодил час и сам не понял, что получил».

Что делаешь:

Открой spec.md и later.md. Спека (spec.md) — это тот документ из одной-двух страниц, который ты написал по гайду «От идеи к спецификации». Там описано, что продукт делает целиком. Файл later.md — это список идей и задач, которые ты раньше отложил на потом (если такого файла нет — сделай).
Выбери ОДНУ задачу на сессию. Не список из пяти, не «хочу сегодня подтянуть всё». Одна задача. Например: «добавить экран истории выпитых бутылок» или «починить отображение каталога на телефоне».
Напиши мини-тз в отдельный файл current-task.md. Это текстовый файл (создай его прямо в папке проекта), в который ты кладёшь одну страницу описания задачи. Claude прочитает его в начале сессии. Формат:

Что хочу: добавить страницу «История» — список выпитых бутылок с датой, оценкой и моим отзывом.

Как пользователь это увидит: в главном меню появляется пункт «История». Он ведёт на отдельный экран со списком бутылок в виде карточек. На каждой карточке: название, дата выпита, оценка звёздочками от 1 до 5, короткий отзыв. Сверху экрана — заголовок «История дегустаций» и кнопка «Назад».

Что НЕ трогать: главный экран каталога, форму добавления бутылки. Они работают — не лезь туда вообще.

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

Три блока: что хочу, как увидит пользователь, что НЕ трогать, плюс «готово когда». Всё. Пять минут работы — и у тебя чёткая постановка.

Блок «что НЕ трогать» — отдельный лайфхак. Без него Claude может из лучших побуждений заодно «улучшить» соседние экраны. С ним — он оставит их в покое.

Фаза 2: Работа (30–90 минут за сессию, не больше)

Теперь открываешь Claude Code.

Шаг 1. Передай задачу. В Claude Code напиши:

Прочти current-task.md. Перескажи своими словами, что ты из этого понял, и задай мне 2–3 уточняющих вопроса, если что-то неоднозначно. Пока ничего не делай.

Ждёшь пересказа. Это ключевой момент: Claude должен подтвердить понимание раньше, чем начал писать код. Если его пересказ совпадает с твоей картинкой — говоришь «всё верно, начинай». Если нет — не торопись. Открой current-task.md и допиши то, что Claude не понял. Потом скажи «перечитай файл».

Секунда ясности сейчас экономит час правок потом.

Шаг 2. Claude работает — ты ждёшь. Не перебивай. Не пиши «а ещё заодно добавь…». Не запускай параллельно вторую задачу. Просто смотри, как Claude меняет файлы, и читай, что он пишет на экране.

Что ты увидишь: Claude показывает, какие файлы он открывает, какие меняет, какие создаёт новые. Читай названия файлов. Если видишь, что он полез в файлы, которых твоя задача не касается («почему он трогает главный экран, если мы делаем историю?») — останови его (Escape или команда stop) и спроси «зачем ты лезешь в этот файл».

Шаг 3. Проверка глазами. Когда Claude закончил, он обычно напишет короткое «что сделано». Читай эту часть обязательно. Это его отчёт о работе.

Дальше — открываешь результат. Скажи Claude:

Запусти сайт и открой его в браузере.

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

Теперь — проверяешь руками:

Открылось ли то, что ты просил? (Есть ли вообще кнопка «История»?)
Выглядит ли примерно так, как ты описал? (Список карточек, заголовок, «Назад».)
Главное: работает ли старая функциональность, которую ты просил НЕ трогать? Открой каталог, открой форму добавления — всё ли как раньше.

Шаг 4а. Если всё ок — коммит.

Сделай коммит с описанием «добавил экран истории дегустаций».

Готово. Задача закрыта. Можно брать следующую — но не в этой сессии, а в следующей. Одна сессия = одна большая задача (или 2–3 маленькие).

Шаг 4б. Если не ок — не продолжаешь править слепо. Не пиши «нет, переделай». Сначала разберись, почему Claude сделал не то. Формула:

Ты сделал X, а мне нужно Y. Объясни своими словами, как ты понял задачу из current-task.md, и что конкретно нужно изменить, чтобы получить Y.

Claude объяснит. Из его ответа ты увидишь одно из двух:

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

Если после второй попытки всё ещё криво — СТОП. Применяй Принцип 4: откатись к последнему рабочему коммиту, переписывай задачу с нуля.

Фаза 3: Закрытие сессии (5 минут)

Не бросай работу на середине. Если ты закроешь Claude Code, когда у тебя незакоммиченные сломанные изменения, — завтра утром ты не вспомнишь, что было в работе, и потеряешь нить.

Что делаешь:

Убедись, что последний рабочий шаг закоммичен. Скажи Claude: «покажи последний коммит и что в нём было». Если видишь, что твоя задача отражена — отлично.
Запиши в later.md: что не успел, какая следующая задача. Одна строчка: «следующее: починить отображение длинных отзывов — вылезают за карточку». Завтра утром откроешь этот файл и за 10 секунд вспомнишь, где остановился.
Закрой Claude Code. Работающий продукт остался у тебя на компьютере. Завтра всё продолжится.

Как читать ответы Claude Code

Claude выдаёт много текста. Читать его целиком — не нужно. Но две вещи читать обязательно:

1. Список изменённых и созданных файлов. Claude всегда показывает, какие файлы он трогал. Если видишь незнакомое название (новый файл, который ты не просил) — это не обязательно плохо, но это вопрос. Спроси:

Зачем ты создал файл [название]? Что он делает и нужен ли он для моей задачи?

Claude объяснит. Если объяснение разумное («это обычная практика, этот файл хранит настройки») — ок. Если невнятное — скажи «удали его, он не нужен для моей задачи».

2. Итоговый отчёт в конце. После работы Claude обычно пишет короткое «что сделано». Читай это обязательно. Это его отчёт о работе. Здесь ты ловишь расхождения: если Claude пишет «я сделал X, Y, Z», а ты просил только X — красный флаг. Останови и переспроси: «я просил только X, зачем ты сделал Y и Z?».

Всё остальное (код, который Claude пишет, шаги с запуском проверок) — можно скользить глазами. Не твоя работа читать каждую строчку кода.

Антипаттерны (чего НЕ делать)

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

1. Накапливать правки одним куском

«Сделай вот эти 5 вещей одним запросом — так быстрее».

Нет, не быстрее. Claude сделает 3 нормально, 2 криво, ты потеряешь ориентиры и не поймёшь, какая из 5 вещей всё сломала. Всегда по одной. Эта ошибка — главная причина, почему новички бросают через неделю.

2. Править кривую работу вместо отката

«Ну Claude почти сделал, сейчас я ещё раз поправлю».

Третья итерация на одной задаче = сигнал SOS. Не правь. Откатывайся к рабочему коммиту и начинай с чистого листа. Это не поражение, это нормальный процесс. Лучше три отката и рабочий результат, чем десять правок и франкенштейн.

3. Оставлять Claude Code открытым на весь день

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

Правило: перезапускай сессию раз в 1–2 часа. Закрыл, открыл заново — Claude стартует с чистой памятью, но все файлы проекта на месте. Никаких потерь.

4. Не читать, что Claude сделал

«Запустил, работает — закоммитил, дальше».

Через 20 коммитов у тебя куча кода, который ты не понимаешь. Однажды что-то сломается — и ты не будешь знать, с какой стороны подходить. Это не значит, что надо читать код построчно. Но отчёт Claude в конце каждой задачи — читай всегда. И список изменённых файлов — тоже.

5. Описывать задачи словами «красивее / удобнее / умнее»

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

6. Бояться откатов

Новичкам психологически больно откатываться — кажется, что час работы в мусор. Это неправильная рамка. Работа не в мусор — ты разобрался, что задача была поставлена нечётко. Этот разбор останется с тобой. А код ты перепишешь за 15 минут с нормальной постановкой — и получишь лучший результат, чем три часа правок кривой версии.

Откат — это не провал. Это нормальная часть рабочего процесса, такая же как коммит.

Что делать, когда застрял

Рано или поздно ты упрёшься в ситуацию «вообще ничего не понимаю, что происходит». Вот алгоритм на такой случай.

Шаг 1. Останови Claude. Нажми Escape или напиши stop. Не давай ему крутиться дальше — он только закопает ситуацию глубже.

Шаг 2. Перечитай последний ответ Claude. Там почти всегда есть подсказка: что он пытался сделать и почему у него не получилось.

Шаг 3. Открой последний рабочий коммит. Скажи Claude:

Покажи, что я поменял с последнего коммита. Сравни текущее состояние с предыдущим.

Ты увидишь список изменений. Из него обычно видно, где что сломалось.

Шаг 4. Откатись. Скажи:

Откатись к коммиту перед последней правкой. Верни проект в то состояние, когда всё работало.

Claude отменит изменения. Ты снова на рабочей точке.

Шаг 5. Переформулируй задачу в current-task.md. Не ту же, что была — лучше. Добавь:

Больше конкретики (числа, позиции, цвета).
Блок «не трогай X, не меняй Y».
Примеры того, как должно выглядеть (можешь даже приложить скриншот другого сайта).

Шаг 6. Попробуй снова — новой сессией (закрой Claude Code и открой заново) с новой задачей.

Если и после этого не получается — напиши: /consult. Живой разбор на твоём примере обычно вытаскивает из таких ситуаций за 20 минут.

Итог

Короткая версия всего, что ты прочитал:

Четыре принципа: один шаг за раз → конкретно в числах → часто коммиться → два промаха, СТОП и откат.
Три фазы сессии: 10 минут планирования (current-task.md) → 30–90 минут работы → 5 минут закрытия.
Обязательно читать две вещи: список изменённых файлов и итоговый отчёт Claude.
Перезапускай сессию раз в 1–2 часа, чтобы Claude не тупил от переполненной памяти.
Откат — норма, не провал. Если промахнулся два раза — откатывайся, а не правь дальше.

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

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

Для тех, кто хочет разобраться в технических деталях

Этот блок можно пропустить. Всё, что нужно для работы, ты уже знаешь. Здесь — просто про то, что происходит под капотом, для любознательных.

Что такое git и коммит на самом деле. Git — это система контроля версий, придумана Линусом Торвальдсом (тем самым, что создал Linux) в 2005 году. Она хранит всю историю твоего проекта в специальной скрытой папке .git внутри папки проекта. Каждый коммит — это «слепок» состояния всех файлов на момент коммита плюс описание, что изменилось. Git умеет в любой момент восстановить любой коммит — это и есть «откат». В профессиональной разработке git — обязательный инструмент, без него не работают вообще. Тебе знать команды git не нужно — Claude знает их за тебя. Но понимать, что коммит = точка сохранения, — важно.

Что такое контекстное окно и почему оно ограничено. Claude Code на каждый твой запрос отправляет в модель всю историю разговора, содержимое прочитанных файлов, результаты его действий. Всё это вместе называется «контекстное окно» — рабочая память модели на данный момент. У современных моделей (Claude 4.5 и 4.6) это окно вмещает сотни тысяч слов, что кажется огромным. Но есть два эффекта: (1) чем больше в окне, тем медленнее модель отвечает; (2) чем больше в окне, тем хуже модель «помнит» что было в начале — внимание размывается по огромному объёму. Поэтому на практике сессия дольше пары часов начинает работать заметно хуже. Это называют «context rot» — деградация качества от переполнения контекста. Лекарство простое: перезапускай сессию. Весь проект останется, память Claude обнулится.

Почему именно 1–2 часа, а не 5 и не 15 минут. Эмпирическое наблюдение. Меньше 30 минут — не успеваешь войти в работу и сделать осмысленный шаг. Больше 2 часов — Claude начинает путаться, ты устаёшь, качество падает. Оптимум — 45–90 минут активной работы, потом коротки перерыв и новая сессия, если ещё есть силы. Это, кстати, тот же принцип, что у «помидоров» (Pomodoro technique) — ограниченные рабочие интервалы с перезапуском внимания работают и для людей, и для языковых моделей.

Почему Claude 4.5 и 4.6, а не 4 или 3.7. Каждая новая версия модели заметно лучше предыдущей в двух вещах, важных для вайб-кодинга: следование инструкциям (меньше отсебятины) и обращение с длинными файлами (меньше ошибок при правках в большом проекте). Claude 4.5 и 4.6 — это те версии, на которых «процесс из этого гайда» работает надёжно. На более старых тебе придётся компенсировать процессом ещё больше — проверять чаще, откатываться быстрее.