Полноценный курс: Claude Code — Вайбкодинг с осознанием (2026)

«Не тот мудрец, кто знает много, а тот, кто знает, зачем ему это знание. Не тот кодер, кто пишет быстро, а тот, кто понимает, что он написал»

Полноценный курс: Claude Code — Вайбкодинг с осознанием (2026)

Методология курса

Этот курс построен на сократическом методе. Мы не будем «закачивать» в тебя информацию — мы будем извлекать понимание через вопросы, практику и рефлексию.

Каждая глава состоит из трёх частей:

1. Теория (вопрос)

Мы начинаем с вопроса, а не с ответа. Ты думаешь, прежде чем читать.

2. Практика (действие)

Ты делаешь руками. Без действий знание мертво.

3. Осознание (рефлексия)

Ты смотришь на результат и задаёшь себе вопросы. Здесь рождается мудрость.

Заведи журнал. Бумажный или в Obsidian — неважно. Важно, чтобы ты записывал свои ответы на рефлексивные вопросы. Без журнала курс превратится в чтение. С журналом — в трансформацию.

Модуль 0. Настройка разума (прежде чем трогать клавиатуру)

Глава 0.1. Кто ты в этом процессе? Прежде чем мы откроем терминал, ответь себе честно: кем ты себя считаешь? Программистом, который использует ИИ? Или пользователем, который заставляет ИИ писать код? Разница между этими ролями — разница между архитектором и каменщиком. Кто из них видит здание целиком?

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

  • формулирует намерение,
  • проверяет результат,
  • исправляет направление,
  • несёт ответственность за итог.

Claude Code — это не замена тебе. Это усилитель твоего мышления. Если твоё мышление мутное — усилитель усилит муть. Если чёткое — усилит чёткость.

Упражнение «Зеркало намерения»

Возьми лист бумаги или открой новый файл. Напиши ответы на три вопроса:

  1. Какую конкретную проблему я хочу решить с помощью Claude Code? (Не «научиться кодить», а «сделать лендинг для X», «автоматизировать Y», «понять Z».)
  2. Что я уже умею в программировании? (Честно. Даже если «ничего» — это тоже ответ.)
  3. Чего я боюсь в этом процессе? (Что не получится? Что ИИ заменит? Что я не пойму, что делаю?)

Не торопись. Дай себе 10 минут. Это не формальность — это калибровка.

Осознание результата

  • Когда ты читал свои ответы — что тебя удивило? Что ты понял о себе впервые?
  • Есть ли противоречие между тем, что ты хочешь, и тем, чего ты боишься? Если да — как это противоречие влияет на твою готовность действовать?
  • Готов ли ты принять, что первые попытки будут несовершенными? Если нет — что нужно изменить в твоих ожиданиях?
Запиши в журнал одну фразу, которая описывает твоё состояние перед началом курса. Это будет твоя «точка А». К ней мы вернёмся в конце. Глава 0.2. Установка Claude Code и первая встреча Ты установил сотни программ. Но задавал ли ты себе вопрос: что происходит, когда ты даёшь ИИ-агенту доступ к своей файловой системе? Это не расширение браузера. Это не плагин. Это сущность, которая может читать, писать и исполнять команды в твоей операционной системе. Понимаешь ли ты, что это значит?

Claude Code — это CLI-агент (и расширение для VS Code), который:

  • читает файлы в твоей рабочей директории,
  • создаёт и редактирует файлы,
  • исполняет команды в терминале (git, npm, python и т.д.),
  • может выходить в интернет через MCP-серверы.

Это большая сила. И, как всегда с большой силой — большая ответственность. Не твоя личная, а техническая: ты должен понимать границы.

Claude Code — это не «волшебная кнопка». Это стажёр с доступом к твоей машине. Стажёр умный, но он может ошибиться. Твоя задача — не доверять слепо, а проверять.

Пошаговая установка

  1. Убедись, что у тебя установлен Node.js 18+. Проверь: node --version
  2. Установи Claude Code глобально: npm install -g @anthropic-ai/claude-code
  3. Перейди в пустую директорию (создай новую для эксперимента): mkdir ~/claude-lab && cd ~/claude-lab
  4. Запусти Claude Code: claude
  5. При первом запуске тебя попросят авторизоваться через браузер. Следуй инструкциям.
  6. Подписка: на момент 2026 года актуальны тарифы Claude Pro ($20/мес) и Max ($100/мес или $200/мес). Для курса достаточно Pro, но Max даёт больше свободы для экспериментов.
Никогда не запускай Claude Code в директории с критически важными файлами без резервной копии и без настройки git. Агент может удалить или перезаписать файлы.

После запуска попробуй первый промпт:

Привет. Расскажи, что ты умеешь в этой директории.

Прочитай ответ. Не торопись. Это твой первый диалог.

Осознание результата

  • Когда ты увидел, что Claude Code может исполнять команды в твоём терминале — что ты почувствовал? Доверие? Тревогу? Любопытство?
  • Прочитав ответ агента на первый промпт — понял ли ты, что он может и чего он не может? Какие границы ты увидел?
  • Если бы ты объяснял другу, что такое Claude Code, за 30 секунд — что бы ты сказал? Попробуй сформулировать сейчас.

Модуль 1. Первый проект: от идеи до работающего кода

Глава 1.1. Дисциплина промпта: inputs определяют outputs Представь, что ты заказываешь обед незнакомому повару. Ты говоришь: «Сделай мне что-нибудь вкусное». Что ты получишь? А теперь представь, что ты говоришь: «Мне нужна паста карбонара, без сливок, с гуанчиале, чтобы желток был жидким». Честный вопрос: почему ты часто разговариваешь с Claude Code так, как будто заказываешь у первого повара?

Закон прост: качество вывода = качество ввода × контекст.

Контекст — это не только твой промпт. Это:

  • файлы в директории (Claude Code их читает),
  • история сессии (что вы обсуждали до этого),
  • CLAUDE.md — специальный файл с инструкциями,
  • MCP-серверы (внешние источники данных).
Промпт — это не «команда». Промпт — это контекстное послание. Чем больше релевантного контекста ты даёшь, тем точнее результат. Но чем больше нерелевантного — тем хуже.

Плохой промпт: «Сделай мне сайт».

Хороший промпт: «Создай одностраничный лендинг на чистом HTML/CSS/JS для сервиса доставки кофе. Стиль — минимализм, тёмная тема. Должна быть форма подписки на email. Используй только vanilla JS, без фреймворков. Размести всё в одном index.html».

Упражнение «Контраст промптов»

  1. В своей директории claude-lab дай Claude Code первый промпт: Сделай мне калькулятор. Посмотри, что получится. Сохрани результат (или запомни).
  2. Очисти директорию (или создай новую). Дай второй промпт: Создай веб-калькулятор в одном файле index.html. Функции: сложение, вычитание, умножение, деление. Интерфейс: сетка кнопок 4x5, дисплей сверху. Стиль: тёмный фон, белые кнопки, оранжевый акцент на операторах. Обработка ошибок при делении на ноль. Без внешних библиотек.
  3. Сравни результаты.

Осознание результата

  • Чем отличались два результата? Не только кодом — но и твоим ощущением от процесса?
  • Какие детали во втором промпте оказались самыми важными? Какие можно было убрать без потери качества?
  • Если бы ты писал промпт в третий раз — что бы ты добавил? Что убрал? Почему?
  • Готов ли ты теперь формулировать промпты для своих реальных задач? Если нет — чего тебе не хватает: знаний, уверенности, практики?
Запиши в журнал свой «идеальный шаблон промпта» — структуру, которую ты будешь использовать. Например: [Что создать] + [Технологии] + [Стиль/дизайн] + [Ограничения] + [Обработка ошибок]. Глава 1.2. Планирование: прежде чем кодить — думай Ты когда-нибудь строил дом, начиная с укладки плитки в ванной, не имея чертежа? Звучит абсурдно. Но именно так работают многие с Claude Code: «давай, делай, посмотрим, что получится». Что происходит с проектом, когда у него нет плана?

Claude Code имеет специальный Plan Mode — режим, в котором он не пишет код, а только планирует. Это переключается через Shift+Tab в CLI или через интерфейс в VS Code.

План — это не формальность. План — это:

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

Упражнение «План перед кодом»

Мы будем делать мини-проект: CLI-утилиту для управления списком задач (todo-list).

  1. Создай новую директорию: mkdir ~/todo-cli && cd ~/todo-cli && git init
  2. Запусти Claude Code и переключись в Plan Mode (Shift+Tab).
  3. Дай промпт: Я хочу создать CLI-утилиту для управления списком задач на Python. Функции: добавить задачу, отметить выполненной, показать список, удалить. Хранение — в JSON-файле. Сначала составь план: архитектура, файлы, функции, порядок реализации. Не пиши код — только план.
  4. Прочитай план. Задай уточняющие вопросы. Попроси изменить то, что тебе не нравится.
  5. Когда план тебя устраивает — переключись обратно в обычный режим и скажи: План принят. Реализуй его по шагам.

Осознание результата

  • Чем отличался процесс с планом от процесса без плана (если ты пробовал оба)?
  • Были ли в плане моменты, которые тебя удивили? Что агент предложил, а ты не ожидал?
  • Сколько итераций планирования тебе потребовалось? Много это или мало? Что ты понял о своём стиле работы?
  • Работает ли утилита? Если нет — на каком этапе возникла проблема? Можно ли было предвидеть её на этапе плана?
Запиши в журнал: «План — это...» (закончи фразу своими словами). Это твоя личная формулировка ценности планирования. Глава 1.3. Построение по фичам: искусство маленьких шагов Можно ли съесть слона за один раз? Можно ли построить небоскрёб за один день? Почему же ты пытаешься заставить Claude Code сделать всё сразу? Что происходит, когда ты даёшь огромную задачу без декомпозиции?

Большая задача — это враг качества. Когда ты говоришь «сделай мне соцсеть», агент:

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

Декомпозиция — это разделение большой задачи на независимые фичи, каждая из которых:

  • может быть реализована за один сеанс,
  • может быть протестирована отдельно,
  • не ломает то, что уже сделано.
Фича — это не «часть проекта». Фича — это законченная единица ценности, которую можно показать, потрогать, проверить.

Упражнение «Фича за фичей»

Продолжим наш todo-cli. Теперь мы будем добавлять фичи по одной.

  1. Фича 1: приоритеты. Добавь возможность указывать приоритет задачи: низкий, средний, высокий. При выводе списка задачи сортируются по приоритету. Обнови план и реализуй. Проверь, что работает. Закоммить в git.
  2. Фича 2: дедлайны. Добавь поле "дедлайн" (дата). При выводе списка просроченные задачи выделяются цветом. Реализуй. Проверь. Закоммить.
  3. Фича 3: теги. Добавь возможность добавлять теги к задачам. Команда "list" должна поддерживать фильтрацию по тегу. Проверь. Закоммить.

Обрати внимание: после каждой фичи ты проверяешь, что старое не сломалось. Это и есть инженерная дисциплина.

Осознание результата

  • Сколько времени заняла каждая фича? Была ли разница между первой и третьей? Почему?
  • Были ли моменты, когда новая фича ломала старую? Как ты это обнаружил? Как исправил?
  • Что ты чувствуешь, глядя на готовый проект? Это «твоё» или «агента»? Где проходит граница?
  • Если бы ты делал этот проект без Claude Code — сколько бы времени заняло? Что это говорит тебе о ценности инструмента?

Модуль 2. Глубокое понимание: как это работает на самом деле

Глава 2.1. Архитектура Claude Code: что под капотом Ты водишь машину. Но понимаешь ли ты, как работает двигатель? Можешь ли ты эффективно использовать инструмент, не понимая его устройства? Что на самом деле происходит, когда ты отправляешь промпт в Claude Code?

Вот упрощённая схема работы Claude Code:

  1. Ты отправляешь промпт + текущий контекст (файлы, история, CLAUDE.md).
  2. Claude Code формирует запрос к модели Claude (через API Anthropic).
  3. Модель возвращает текст + tool calls (вызовы инструментов: чтение файла, запись файла, выполнение команды).
  4. Claude Code исполняет tool calls локально на твоей машине.
  5. Результаты возвращаются модели как новый контекст.
  6. Цикл повторяется, пока модель не решит, что задача выполнена.
Claude Code — это цикл «подумал → сделал → посмотрел → подумал ещё». Каждое действие — это итерация. Чем сложнее задача, тем больше итераций. Чем больше итераций — тем больше токенов. Чем больше токенов — тем дороже и дольше.

Отсюда следуют практические выводы:

  • Чёткий промпт = меньше итераций = быстрее и дешевле.
  • Большой контекст = больше токенов на итерацию = дороже.
  • Автономные циклы без контроля = риск потратить много токенов впустую.

Упражнение «Наблюдение за циклом»

  1. В CLI Claude Code включи режим отладки: claude --verbose
  2. Дай задачу: Создай файл hello.py, который выводит "Hello, World!", и запусти его.
  3. Наблюдай за тем, какие tool calls делает агент. Записывай: чтение файла → запись файла → выполнение команды → чтение вывода.
  4. Посмотри в конце сессии на статистику использования токенов (команда /cost или /status).

Осознание результата

  • Сколько итераций потребовалось для такой простой задачи? Удивило ли тебя это количество?
  • Были ли «лишние» действия, которые агент сделал, но которые не были нужны? Почему он их сделал?
  • Сколько токенов было потрачено? Переведи это в деньги (по тарифу твоей подписки). Много это или мало для такой задачи?
  • Что ты понял о «цене» каждого своего промпта? Изменилось ли твоё отношение к формулировкам?
Глава 2.2. Контекстные окна: управление памятью У тебя есть друг, который помнит только последние 20 минут разговора. Как ты будешь с ним общаться? Будешь ли ты повторять важное? Будешь ли ты записывать ключевые мысли? Контекстное окно Claude — это и есть такой друг. Как ты будешь с ним работать?

Контекстное окно — это объём информации, который модель может «держать в голове» одновременно. У современных Claude это сотни тысяч токенов, но:

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

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

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

Упражнение «CLAUDE.md как контракт»

  1. В директории своего todo-cli создай файл CLAUDE.md.
  2. Напиши туда: # Todo CLI ## Описание CLI-утилита для управления задачами на Python. ## Архитектура - `main.py` — точка входа - `storage.py` — работа с JSON-файлом - `cli.py` — обработка команд ## Стиль кода - Python 3.10+ - Типизация обязательна - Docstrings для всех функций - Обработка ошибок с понятными сообщениями ## Тестирование После каждого изменения запускай: `python main.py --help` и проверяй базовые сценарии. ## Запреты - Не используй внешние библиотеки без согласования - Не меняй структуру хранения без предупреждения
  3. Запусти новую сессию Claude Code в этой директории. Спроси: Прочитай CLAUDE.md и расскажи, что ты понял о проекте.
  4. Попроси добавить новую фичу — и посмотри, как агент учитывает инструкции из CLAUDE.md.

Осознание результата

  • Как изменилось поведение агента после создания CLAUDE.md? Стал ли он точнее?
  • Какие пункты CLAUDE.md оказались самыми полезными? Какие — избыточными?
  • Если бы ты передал этот проект другому разработчику (человеку или ИИ) — понял бы он его по CLAUDE.md? Что нужно добавить?
  • Готов ли ты вести CLAUDE.md для всех своих проектов? Что тебя останавливает, если нет?
Глава 2.3. Code Review: не доверяй — проверяй Представь, что тебе привезли коробку с надписью «осторожно, стекло». Ты откроешь и проверишь? Или поверишь на слово? Почему же ты принимаешь код от Claude Code без проверки?

Claude Code может:

  • галлюцинировать — выдумывать несуществующие функции, библиотеки, API,
  • допускать логические ошибки — особенно в сложных алгоритмах,
  • создавать уязвимости — SQL-инъекции, XSS, небезопасное хранение данных,
  • писать неоптимальный код — работающий, но медленный или нечитаемый.

Твоя задача как инженера — не принимать код на веру. Используй чек-лист:

  • Код запускается без ошибок?
  • Все ли функции из ТЗ реализованы?
  • Есть ли обработка ошибок (деление на ноль, отсутствующие файлы, невалидный ввод)?
  • Нет ли хардкода секретов (паролей, ключей)?
  • Понятен ли код? Можешь ли ты его объяснить?
  • Соответствует ли код стилю, указанному в CLAUDE.md?
  • Пройдён ли код через статический анализатор (если применимо)?

Упражнение «Найди ошибку»

  1. Попроси Claude Code написать функцию, которая читает CSV-файл и считает сумму по колонке «amount».
  2. Получив код — не запускай сразу. Прочитай его строчка за строчкой.
  3. Задай себе вопросы:
    • Что будет, если файл пустой?
    • Что будет, если в колонке не число?
    • Что будет, если файл не существует?
    • Что будет, если CSV очень большой (10 ГБ)?
  4. Найденные проблемы запиши. Потом попроси агента их исправить — и сравни, что он учёл, а что нет.

Осознание результата

  • Сколько проблем ты нашёл до запуска? Сколько нашлось при запуске?
  • Были ли проблемы, которые ты не заметил, но которые нашлись позже? Почему ты их пропустил?
  • Как изменилось твоё доверие к агенту после этого упражнения? Стало ли оно более зрелым?
  • Готов ли ты применять этот чек-лист к каждому куску кода? Что нужно, чтобы это стало привычкой?

Модуль 3. Продвинутые техники: MCP, агенты, автоматизация

Глава 3.1. MCP-серверы: даём агенту руки Claude Code по умолчанию может читать файлы и исполнять команды. Но что, если тебе нужно, чтобы он работал с базой данных? С API Telegram? С Notion? С твоим умным домом? Как дать агенту доступ к внешнему миру — и не потерять контроль?

MCP (Model Context Protocol) — это стандарт, который позволяет подключать к Claude внешние инструменты. MCP-сервер — это программа, которая:

  • предоставляет агенту набор функций (tools),
  • агент может вызывать эти функции через стандартный интерфейс,
  • сервер исполняет действия в реальном мире (пишет в БД, отправляет email, читает API).

Примеры MCP-серверов:

  • filesystem — расширенная работа с файловой системой,
  • postgres — прямые запросы к PostgreSQL,
  • github — работа с репозиториями, issue, PR,
  • slack — отправка сообщений в каналы,
  • memory — персистентная память между сессиями.
MCP — это мост между миром модели и миром данных. Без MCP агент живёт в вакууме. С MCP — он становится частью твоей инфраструктуры.

Упражнение «Первый MCP-сервер»

Мы создадим простой MCP-сервер на Python, который будет давать агенту доступ к «книге заметок».

  1. Создай директорию: mkdir ~/mcp-notes && cd ~/mcp-notes
  2. Создай файл server.py: from mcp.server.fastmcp import FastMCP import json from pathlib import Path mcp = FastMCP("notes") NOTES_FILE = Path("notes.json") def load_notes(): if NOTES_FILE.exists(): return json.loads(NOTES_FILE.read_text()) return [] def save_notes(notes): NOTES_FILE.write_text(json.dumps(notes, indent=2, ensure_ascii=False)) @mcp.tool() def add_note(title: str, content: str) -> str: """Добавить заметку с заголовком и содержимым""" notes = load_notes() notes.append({"title": title, "content": content}) save_notes(notes) return f"Заметка '{title}' добавлена" @mcp.tool() def list_notes() -> str: """Показать все заметки""" notes = load_notes() if not notes: return "Заметок нет" return "\n".join(f"- {n['title']}: {n['content']}" for n in notes) @mcp.tool() def search_notes(query: str) -> str: """Найти заметки по запросу""" notes = load_notes() found = [n for n in notes if query.lower() in n['title'].lower() or query.lower() in n['content'].lower()] if not found: return "Ничего не найдено" return "\n".join(f"- {n['title']}: {n['content']}" for n in found) if __name__ == "__main__": mcp.run()
  3. Установи зависимости: pip install mcp
  4. Добавь сервер в конфигурацию Claude Code. Отредактируй ~/.claude/settings.json: { "mcpServers": { "notes": { "command": "python", "args": ["/путь/к/mcp-notes/server.py"] } } }
  5. Перезапусти Claude Code. Теперь у него есть новые инструменты: add_note, list_notes, search_notes.
  6. Проверь: Добавь заметку "Идея курса" с содержимым "Сделать курс по MCP" А потом: Покажи все мои заметки

Осознание результата

  • Что ты почувствовал, когда агент впервые вызвал твой MCP-инструмент? Это было «волшебство» или «инженерия»?
  • Какие ещё данные или сервисы ты хотел бы подключить через MCP? Составь список из 5 идей.
  • Какие риски есть в том, чтобы давать агенту доступ к внешним системам? Как ты будешь их контролировать?
  • Понимаешь ли ты теперь разницу между «агентом в вакууме» и «агентом в инфраструктуре»? Как это меняет твоё представление о возможностях?
Глава 3.2. Агенты и саб-агенты: оркестр, а не соло Один программист может написать проект. Но может ли один программист написать операционную систему, браузер и сервер одновременно? Когда задача становится слишком большой для одного агента — что делать?

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

Когда это полезно:

  • параллельная работа над независимыми модулями,
  • разделение задач по контексту (чтобы не раздувать одно окно),
  • специализация (один агент — по фронтенду, другой — по бэкенду).
Суб-агенты — это не «бесплатно». Каждый суб-агент тратит токены. Не создавай их ради красоты — создавай, когда это действительно экономит время и контекст.

Упражнение «Параллельная разработка»

Создадим веб-приложение: бэкенд на FastAPI + фронтенд на vanilla JS.

  1. Создай проект: mkdir ~/web-app && cd ~/web-app && git init
  2. Составь план с главным агентом: Спланируй веб-приложение: бэкенд на FastAPI (API для задач), фронтенд на vanilla JS. Сначала план архитектуры, файлов, API-контракта.
  3. Когда план готов — делегируй: Запусти два суб-агента параллельно: 1. Один реализует бэкенд по плану (директория backend/) 2. Второй реализует фронтенд по плану (директория frontend/) Они должны работать независимо, но соблюдать API-контракт из плана.
  4. После завершения — проверь, что фронтенд и бэкенд работают вместе.

Осознание результата

  • Сколько времени заняла параллельная работа по сравнению с последовательной? (Если есть возможность — сравни.)
  • Были ли моменты, когда суб-агенты «не договорились» (разные имена полей, разные форматы)? Как ты это обнаружил?
  • Что сложнее: написать код самому или скоординировать работу нескольких агентов? Почему?
  • В каких твоих реальных задачах параллелизация дала бы наибольший выигрыш?
Глава 3.3. Хуки и slash-команды: автоматизация рутины Ты делаешь одно и то же действие третий раз за день. Почему ты всё ещё делаешь его вручную? Что в твоей работе с Claude Code повторяется чаще всего — и как это автоматизировать?

Slash-команды — это быстрые действия в CLI Claude Code:

  • /help — помощь,
  • /compact — сжать историю,
  • /clear — очистить сессию,
  • /cost — показать использование токенов,
  • /init — инициализировать CLAUDE.md,
  • /review — ревью кода,
  • /doctor — диагностика,
  • /vim — vim-режим,
  • /terminal-setup — настройка shell-интеграции,
  • /theme — смена темы.

Хуки — это события, на которые можно подписаться. Например:

  • PreToolUse — перед вызовом инструмента (можно отменить или модифицировать),
  • PostToolUse — после вызова инструмента,
  • Notification — при уведомлении,
  • Stop — когда агент заканчивает работу.

Хуки настраиваются в .claude/settings.json и позволяют запускать скрипты в ответ на события.

Упражнение «Автоматизация через хуки»

  1. Создай в проекте файл .claude/settings.json (если его нет).
  2. Добавь хук, который запускает тесты после каждого изменения кода: { "hooks": { "PostToolUse": [ { "matcher": "write_file|edit_file", "hooks": [ { "type": "command", "command": "python -m pytest tests/ -q 2>&1 | tail -5" } ] } ] } }
  3. Теперь после каждого изменения файла агент будет автоматически запускать тесты и видеть результат.
  4. Попробуй попросить агента изменить что-то — и посмотри, как хук срабатывает.

Осознание результата

  • Какие ещё действия в твоей работе можно автоматизировать через хуки? Составь список из 5 идей.
  • Есть ли опасность в автоматизации? Что может пойти не так, если хук срабатывает слишком часто или в неподходящий момент?
  • Как ты будешь отлаживать хуки, если они начнут работать неправильно?
  • Что для тебя важнее: скорость или контроль? Как хуки влияют на этот баланс?

Модуль 4. Зрелость: инженерия ПО в эпоху ИИ

Глава 4.1. Границы возможностей: что Claude Code НЕ может Ты знаешь, что инструмент может. Но знаешь ли ты, чего он не может? Можно ли по-настоящему мастерски использовать то, границы чего ты не осознаёшь?

Claude Code не может:

  • Понимать бизнес-контекст за пределами того, что ты ему скажешь. Он не знает твоих пользователей, твоего рынка, твоих ограничений.
  • Принимать ответственные решения. Выбор между двумя архитектурами — это твоя ответственность, не его.
  • Гарантировать корректность. Он может ошибаться, и он будет ошибаться.
  • Работать с очень большими кодовыми базами целиком. Контекст ограничен. Он не «видит» весь проект сразу.
  • Заменять инженерное мышление. Он усиливает его — но только если оно у тебя есть.
  • Писшить код, который ты не сможешь поддерживать. Если ты не понимаешь, что он написал — ты не сможешь это чинить.
Мастерство в вайбкодинге — это не «научиться писать промпты». Это научиться понимать границы и действовать внутри них.

Упражнение «Карта границ»

  1. Возьми свой текущий проект (todo-cli, web-app или любой другой).
  2. Попытайся дать Claude Code задачу, которая заведомо на грани его возможностей. Например:
    • «Перепиши весь проект с нуля на другом языке, сохранив поведение»
    • «Найди все баги в проекте»
    • «Оптимизируй проект по скорости в 10 раз»
    • «Сделай проект production-ready»
  3. Наблюдай, где агент начинает ошибаться, упрощать, галлюцинировать.
  4. Зафиксируй эти моменты.

Осознание результата

  • Где именно агент «сломался»? Что это говорит о природе его ограничений?
  • Были ли моменты, когда ты понял, что задача была не по силам агенту, но ты всё равно её дал? Почему?
  • Как ты будешь использовать эту карту границ в реальной работе? Что ты теперь будешь делать сам, а что — делегировать?
  • Изменилось ли твоё отношение к Claude Code после этого упражнения? Стало ли оно более реалистичным?
Глава 4.2. Инженерия ПО как дисциплина (а не как ремесло) Можно ли называть себя поваром, если ты умеешь только разогревать готовое? Можно ли называть себя инженером, если ты только заказываешь код у ИИ? Что делает инженера — инженером?

Инженерия ПО — это не «написание кода». Это:

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

Claude Code не заменяет ни один из этих пунктов. Он ускоряет некоторые из них — но только если ты сам их выполняешь.

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

Упражнение «Инженерный журнал»

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

  • Какую проблему я решаю? (Не «пишу код», а «решаю проблему X».)
  • Какие варианты решения я рассмотрел? (Даже если агент предложил один — ты должен был подумать о других.)
  • Почему я выбрал этот вариант? (Обоснование, а не «так получилось».)
  • Что я проверил? (Тесты, ревью, запуск.)
  • Что я понял нового? (О проблеме, о коде, о себе.)

Осознание результата

  • Через неделю перечитай журнал. Что ты видишь? Это работа инженера или работа «нажимателя кнопок»?
  • Были ли дни, когда ты ловил себя на том, что действуешь без мышления? Что это за моменты?
  • Как ведение журнала изменило твою работу? Стал ли ты более осознанным?
  • Готов ли ты назвать себя инженером — даже если большую часть кода пишет ИИ? Почему да или почему нет?

Финал. Возвращение к точке А

Большая рефлексия: кто ты теперь?

В начале курса ты записал в журнал «точку А» — фразу, описывающую твоё состояние. Найди эту запись. Прочитай её сейчас.

А теперь ответь на вопросы — честно, без спешки, письменно:

  • Что ты знаешь сейчас, чего не знал тогда? Не о Claude Code — о себе, о процессе, о природе инженерной работы.
  • Какие из твоих страхов подтвердились? А какие — оказались преувеличены?
  • Что ты сделал такого, чего не сделал бы месяц назад? Какой проект, какая задача, какое решение?
  • Где ты всё ещё слаб? Не для самобичевания — для карты роста. Что ты будешь развивать дальше?
  • Как изменилось твоё определение «программиста»? Нужно ли уметь писать код руками, чтобы быть программистом в 2026 году?
  • Что ты скажешь человеку, который только начинает этот курс? Какой один совет ты бы дал себе в начале?

Запиши теперь «точку Б» — фразу, описывающую твоё текущее состояние. Сравни с точкой А.

Это и есть результат курса. Не код, который ты написал. Не проекты, которые ты сделал. А изменение в твоём мышлении.

«Мудрость — это не знание, а понимание того, что ты знаешь, и того, чего ты не знаешь»
— Сократ (перефраз)

Дорожная карта: что дальше?

Курс закончен. Но обучение — нет. Вот пути, по которым ты можешь идти дальше:

  • Углубление в MCP: создай 3 собственных MCP-сервера для своих реальных задач.
  • Агентные системы: изучи фреймворки вроде LangGraph, CrewAI — пойми, как строить многоагентные системы.
  • Специализация: выбери область (веб, данные, ML, инфраструктура) и стань в ней экспертом по вайбкодингу.
  • Преподавание: лучший способ понять — научить другого. Найди ментори и проведи его через этот путь.
  • Исследование границ: постоянно тестируй, что может и чего не может Claude Code. Документируй.
  • Сообщество: вступай в дискуссии, делись опытом, учись у других.
Путь мастера — это не конечная точка. Это бесконечная практика осознанности. Каждый проект — это возможность стать чуть лучше. Каждый промпт — возможность подумать чуть глубже.

Теги: AI-агент, Cursor, RAG, API, Нейросеть, Промпт, Токен, Контекст, Контекстное окно