AI умножает не навыки. Он умножает привычки.
За последний год я написал примерно втрое больше кода. Это правда. AI-инструменты реально ускоряют. Но если честно, значительную часть этого кода я потом удалил.
Нарратив «AI умножает ваши навыки» правдив. Только он неполный. Умножитель не разбирает, что именно умножать. Он берёт то, что вы в него подаёте, и делает больше. Хорошие практики — больше хороших практик. Плохие привычки — больше плохих привычек, только быстрее.
Это я понял не из статьи. Из собственных логов.
Что значит «AI умножает навыки» — на деле
Когда я пишу задачу для Claude Code с чётким спеком, описанием входов, выходов и граничных случаев, результат обычно хорош с первой попытки. Когда я пишу «сделай мне X, вот контекст» без спека, результат технически работает, но скрывает предположения, которые вылезут через три недели.
Разница — не в мощности модели. Разница в том, что я принёс на вход.
Если у вас есть привычка писать спек перед кодом — с AI вы делаете это быстрее и чище. Если нет этой привычки — AI поможет вам накапливать последствия с той же скоростью. Просто без трения, которое раньше хоть немного замедляло.
Три привычки, которые AI умножает с особой охотой
1. Начинать задачу без спека
Раньше начать без спека означало: разберусь по ходу. Разбирались. Медленно, потому что код сам притормаживал. Задашь вопрос, переключишься, прочитаешь, подумаешь.
С AI этот тормоз пропал. Я отдаю неструктурированный запрос, Claude Code генерирует несколько сотен строк кода за 30 секунд. Код выглядит убедительно. Он даже тесты написал. Я смотрю — «окей, работает», и иду дальше.
Через неделю оказывается, что задача решена под неправильные предположения. AI не угадывал — он сделал разумные догадки на основе контекста. Просто этот контекст был неполным, потому что я не потрудился его сформулировать.
Итог: не «потратил вечер на неправильное решение», а «потратил два вечера, потому что написал быстро, а потом разбирался долго».
Я разобрал это подробнее в статье про spec-first подход перед работой с AI. Если коротко: 5 вопросов до первого prompt'а сокращают переделки вдвое.
2. Не фиксировать «почему» за архитектурными решениями
Это привычка, которую легко откладывать. «Запомню». «Это очевидно». Потом.
С AI эта привычка дала новый эффект. Я прошу Claude Code дописать функцию или рефакторнуть модуль. Он смотрит на код и делает что-то разумное. Но он не знает, почему три месяца назад я выбрал именно эту структуру, а не другую. Потому что я это тоже не записал.
Результат: AI предлагает изменения, которые технически корректны, но нарушают инварианты, которые «все знают» — только молча. Кто «все»? Я и мои прошлые мысли, которые нигде не зафиксированы.
Конкретный пример: у меня в одном из проектов был нестандартный порядок обработки скидок в Bitrix. Логика держалась в голове. Когда я попросил AI помочь с рефакторингом этого блока, он сделал «правильно» по стандартам Bitrix — и сломал расчёт. Не потому что он плохой. Потому что я не написал «вот почему здесь так».
Это не про документацию ради документации. Это про то, что AI работает с тем, что написано, а не с тем, что подразумевается.
3. Откладывать мониторинг «на потом»
Это классика. «Сначала сделаю, потом добавлю логирование». AI не помогает с этой проблемой. AI идеально помогает сделать «сначала» — быстро и убедительно. А «потом» так и остаётся потом.
Я написал об этом конкретном случае в посте про AI-баг, который провёл неделю в продакшне. Там баг существовал семь дней, пока его не нашли по логам. Но логи были неполные. Потому что мы откладывали нормальное логирование. AI тут ни при чём — он написал функцию правильно по спеку. Спек не учитывал граничный случай, а логов не было, чтобы это заметить быстро.
AI сгенерировал систему, в которой observability была «на потом», потому что я именно так её описал: «сделай X, логирование добавим». Умножитель сработал.
Что я поменял: spec-first как шаг до prompt'а
Сейчас у меня есть простое правило: не открывать Claude Code, пока не ответил на пять вопросов.
- Что именно делает эта функция — в одном предложении?
- Кто вызывает, с каким входом?
- Что ожидается на выходе — включая граничные случаи?
- Есть ли ограничения (производительность, зависимости, инварианты)?
- Как я пойму, что оно работает правильно?
Пять минут. Иногда я понимаю, что не знаю ответа на второй вопрос, и это уже полезно — потому что без AI я бы тоже начал и нашёл это через час кода, а не через пять минут.
Это не волшебство. Это просто возврат трения туда, где оно помогает: перед генерацией, а не после.
Для автономных задач я описал это отдельно — как писать задачи для AI-агентов без человека в контуре. Принцип тот же: если вы не можете сформулировать exit condition, агент не сможет корректно остановиться.
Что не работает: ждать напоминания от AI
Первая реакция на эту проблему обычно такая: «Хорошо, буду просить AI напоминать мне про спек». Пробовал. Не работает системно.
AI напомнит, если вы его попросите. Но если вы не попросили — он ответит на вопрос, который задали. Это не недостаток модели. Это нормальное поведение инструмента: он делает то, что ему говорят.
Рассчитывать, что AI выловит пропущенные привычки — всё равно что рассчитывать, что компилятор скажет вам про неправильные бизнес-требования. Компилятор проверяет синтаксис. AI проверяет то, что вы явно описали.
Мне это стало совсем очевидно после того, как я начал разбирать, где AI в code review систематически ошибается — об этом есть отдельный пост. Слепые зоны AI почти всегда там, где у разработчика тоже есть слепое пятно.
Умножитель нейтрален
AI — это форсирующая функция. Она форсирует то, что уже есть.
Если у вас хорошие привычки — spec-first, фиксация решений, ранний мониторинг — AI поможет делать это быстрее и системнее. Я видел, как это работает.
Если привычек нет или они плохие — последствия накапливаются с той же скоростью, что и код. Это тоже видел.
Нарратив «AI умножает навыки» правдив в лучшем смысле слова. Только навыки — это не код, который вы пишете. Навыки — это то, что вы делаете до того, как открываете редактор.
Умножитель берёт то, что вы приносите. Что вы туда кладёте — ваш выбор.