ИИ-ассистенты для кода: 5 мифов под проверкой
ИИ-ассистенты ускоряют набор кода, но не качество софта. Проверяем пять мифов на реальных узких местах: дизайн, верификация и сложность.

Джонатан Блоу, дизайнер игр Braid и The Witness и упрямец, который потратил десять лет на создание собственного языка программирования, недавно задал вопрос, который должен неприятно колоть каждого вендора, продающего ИИ-ассистентов для кода: если ИИ решил задачу написания кода, почему мой софт всё такой же? Те же падения. Те же раздутые обновления. Те же жалобы десятилетней давности на приложения, которые жрут оперативку и при этом умеют меньше, чем инструменты, которые они заменили. Привычный ответ «подождите полгода» не закрывает вопрос, и я не думаю, что Блоу неправ, когда тычет в больное место.
Вот моя позиция, после нескольких лет работы с ML-системами и наблюдения за тем, как эти инструменты приходят в реальные команды: ИИ-ассистенты для кода сейчас действительно хороши, и при этом они реально не сдвинули ситуацию с софтом, которым мы с вами пользуемся каждый день. Оба утверждения верны одновременно, и причина в том, что инструменты никогда не были нацелены на главное ограничение. Самый наглядный способ это увидеть — взять пять убеждений, которые я слышу чаще всего, и проверить каждое.
Миф 1: набор текста — узкое место разработки
Аргумент сам напрашивается: программирование — это производство кода, значит машина, которая производит код в десять раз быстрее, делает софт в десять раз быстрее. Аккуратный силлогизм с одним изъяном: ничья работа на самом деле так не выглядит. Есть старое эмпирическое правило, популяризированное книгой Clean Code, по которому разработчики тратят на чтение кода заметно больше чем в десять раз дольше, чем на его написание. Это соотношение старше LLM лет на пятнадцать, но любой серьёзный разбор того, как тратятся инженерные часы, приходит к одному и тому же: понимание существующей системы, согласование с другими людьми, ожидание решений. Нажатия клавиш — погрешность округления.
Это легко почувствовать на своей неделе. Автодополнение экономит реальные минуты, без него я бы уже не смог, но мои тяжёлые дни никогда не были тяжёлыми из-за того, что я не успевал печатать. Они были тяжёлыми, потому что в платёжном сервисе был инвариант, который никто не записал, или потому что три команды не сошлись во мнении о том, что API должен обещать. Ускорение единственного этапа, который не был медленным, почти ничего не даёт общей пропускной способности. Завод, который штампует детали быстрее, чем линия контроля успевает их принимать, не выпускает больше продукции. Он просто выпускает большую гору деталей.
Есть одно место, где набор текста действительно является узким местом: работа с чистого листа, где нет существующей системы, с которой надо считаться. Шаблонный код, прототипы, одноразовые скрипты, первая версия чего угодно. Именно поэтому демо выглядят как магия: демо всегда про чистый лист. Продакшн-инженерия почти целиком про работу с существующим кодом, а работа с существующим кодом — это в первую очередь чтение.
Миф 2: код, написанный ИИ, приходит уже проверенным
Оптимистичный сценарий выглядит так: описываешь задачу, модель пишет код, тесты проходят, мержишь. Проблема сидит в середине. «Тесты прошли» говорит лишь о том, что тесты, которые вы додумались написать, согласуются с кодом, который модель додумалась написать. Оба могут ошибаться в одном и том же направлении, и с выводом LLM это часто так и происходит: модель выдаёт гладкий, идиоматичный, уверенный код, а гладкость как раз и усыпляет ревью.
Вот небольшой пример, который я видел в природе, по сути если не в точности. Попросите планировщик ежемесячных задач, и вы получите примерно такое:
from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate
Читайте это так, как читали бы pull request коллеги. Идиоматично. Переход через год обработан. Докстринг даже точный. Теперь запустите это 15 апреля с day=31: now.replace(day=31) выбрасывает ValueError, потому что в апреле нет 31-го числа. Функция падает именно на самом частом запросе планировщика, на конце месяца, и только в коротких месяцах, поэтому может спокойно выглядеть здоровой в продакшене неделями, пока кто-нибудь не заметит. Тест, который перебирает целый год значений now, поймает это за секунды. Внимательный человек-ревьюер замечает такое, может быть, в половине случаев. Этот разрыв и есть проблема верификации в миниатюре.
Поэтому я продолжаю настаивать, что в рабочем процессе с большой долей ИИ выбор между проверкой понимания и тестами — не академический вопрос, а суть всей игры. Читать чужой код и так труднее, чем писать его. Читать код, который не писал ни один человек, в тех объёмах, которые выдают эти инструменты, полностью переворачивает экономику ревью. Команды, с которыми я общаюсь, больше не испытывают нехватки кода. Им не хватает людей, которые понимают, что делает код, и готовы подписаться под ним.

Миф 3: дешёвый код делает дизайн софта дешёвым
Более тонкое убеждение: если код почти ничего не стоит, архитектура важна меньше, потому что всегда можно переписать. Плохая абстракция? Сгенерируем заново. Неверная модель данных? Тоже перегенерируем. Я слышал, как старшие инженеры говорят это с серьёзным лицом, и это путает стоимость изменения текста со стоимостью изменения решений.
Трудная часть софта никогда не была в коде. Она в том, чтобы решить, что вообще стоит строить, смоделировать запутанную человеческую предметную область так, чтобы машина смогла её исполнить, и делать архитектурные ставки, которые не развалятся, когда требования меняются, а они всегда меняются. Это задачи намерений и ценностей, а не завершения шаблонов. Модель, обученная на корпусе существующего софта, может рассказать, как обычно выглядят системы, похожие на вашу. Она не может сказать, как должна выглядеть ваша, потому что ответ живёт в ваших пользователях, ограничениях и аппетите организации к риску. На этом фронте мы практически не продвинулись, и я бы утверждал, что это не разрыв в возможностях, который можно выровнять масштабом. Это ошибка категории.
Переписывание тоже не бесплатно. Большая часть инженерных денег уходит на изменение уже существующих систем, а изменить систему значит сначала восстановить по коду намерения, в неё заложенные: инварианты, которые никто не задокументировал, краевой случай, который оказывается несущим для одного важного клиента. Модель этих намерений не знает. Часто не знает и команда. Это тот самый разрыв между спецификацией и реализацией, где на самом деле живут баги, и генерация большего объёма реализации лишь расширяет его, если кто-то не держит спецификацию в жёстком кулаке.
У Фреда Брукса есть термин для того, что делает софт цельным: концептуальная целостность, ощущение, что решения принимал один ум или несколько согласованных умов. Беглая генерация кода к ней не ведёт. Если уж на то пошло, она делает дешевле тысячу несогласованных микрорешений, и именно так получаются системы, которые выглядят спроектированными, а на ощупь собраны из кусков.
Миф 4: неизменившийся софт доказывает провал ИИ-кодинга
Теперь контраргумент, потому что рамка Блоу тоже не непробиваема. Если посмотреть мимо массового коммерческого софта, things действительно движутся. Инди-геймдев выпустил стратегии с собственными движками от крошечных команд, которые десять лет назад потребовали бы штата Blizzard. Ещё заметнее для меня тихий рост личного софта: люди пишут собственные почтовые клиенты, календари, трекеры финансов и git-фронтенды, заточенные именно под то, как они думают. Эти инструменты грубоваты и никогда не выдержали бы выпуска для десяти тысяч незнакомцев. Но они существуют, каждый день ими пользуются, и раньше их просто не окупало создавать.
Даже организации меняются так, что заголовочная метрика этого не видит. Я знаю компании, чей план модернизации по сути сводится к следующему: открыть legacy-систему через нормальные API и дать сотрудникам собирать поверх них свои эндпоинты и интерфейсы с помощью агентного инструмента для кода. Это не «мой софт выглядит так же». Это софт, растворяющийся в чём-то более личном, невидимом, если вы смотрите только на чарты магазинов приложений.
Более глубокая причина, по которой наблюдение Блоу ощущается верным, организационная, а не техническая. Коммерческий софт формируется тем, что оптимизируют компании: вовлечённость, привязку к себе, темп релизов, стоимость поддержки. ИИ даёт больше того, что вам уже нужно, и быстрее. Он не меняет того, чего вы хотите. Компания, которая выпускала раздутый софт, потому что раздутость не значилась в её смете, будет выпускать раздутый софт и на более коротком цикле разработки. Планка качества для софта, который получают тысячи пользователей, задаётся стимулами, дисциплиной тестирования и вкусом, и ни одно из этих вещей не является выводом модели.
Есть и простой аргумент про лаг. Действительно надёжному ИИ-кодингу примерно год; до этого он был нестабильным, а ещё раньше был игрушкой. Продукты задумываются, строятся и выпускаются годами. Судить о влиянии этих инструментов на выпущенный софт прямо сейчас всё равно что оценивать новый плуг по урожаю через месяц после его изобретения.
Миф 5: следующая модель закроет разрыв
Самая сильная версия аргумента оптимиста: каждое возражение выше описывает сегодняшние модели, а сегодняшние модели — худшие, которыми мы когда-либо будем пользоваться. Отчасти верно. Контекстные окна вырастут, выдуманных API станет меньше, агенты научатся лучше запускать собственные тесты. Я ожидаю реальных улучшений, особенно на хорошо специфицированных задачах.
Но обратите внимание, какие узкие места являются проблемами возможностей, а какие нет. Верификация становится проще по мере роста надёжности моделей, и это вопрос возможностей. Решение, что стоит строить, сохранение концептуальной целостности, смена того, что оптимизирует организация, — этого нет ни в одной дорожной карте моделей, потому что это не проблемы моделей. И осторожнее с прогрессом бенчмарков как доказательством: бенчмарки пропускают большую часть того, как выглядит реальная работа, а реальная работа как раз слабо специфицирована и насыщена намерениями.
Так что вот мой прогноз, зафиксирую его: инструменты станут заметно лучше для отдельных разработчиков и небольших команд с хорошим вкусом, а массовый софт станет лучше лишь незначительно, если вообще — потому что там ограничением никогда не был код. Если это звучит пессимистично, это не так. Это значит, что рычаг находится в ваших руках и в оргструктуре, а не в следующем релизе лаборатории.

Что на самом деле улучшает качество софта
Если генерация дешёвая, а верификация дорогая, разумная реакция — сместить инвестиции. Конкретно:
- Относитесь к тестам и типам как к продакшн-инфраструктуре. Property-based тесты, проверки инвариантов и быстрый CI превращают дешёвую генерацию в дешёвую правильную генерацию. Закладывайте на них бюджет так же, как на вычислительные ресурсы.
- Пишите спецификацию раньше промпта. Спецификация теперь самый ценный артефакт команды, потому что модель её не даст, а ревьюеры сверяются именно с ней.
- Используйте ИИ там, где он действительно силён: прототипы с чистого листа, миграции, шаблонный код, личные инструменты, быстрое исследование пространства решений. Относитесь с подозрением к нему на несущих legacy-путях, где намерения не задокументированы.
- Защищайте время на проектирование. Когда скорость генерации утраивается, возникает соблазн заполнить roadmap втрое. Сопротивляйтесь. Решать и есть работа.
Узким местом никогда не был набор текста. Всегда им было решение, а потом доказательство.
На вопрос Блоу есть ответ, и если читать его правильно, он обнадёживает. Софт выглядит одинаково, потому что его качество всегда определялось решением, проверкой и заботой. ИИ-ассистенты при всей своей реальной пользе ускоряют то, что никогда не было медленным. Значит, инструменты для улучшения софта остаются прежними: вкус, спецификация и дисциплина доказывать. Модели просто сделали невозможным дальше делать вид, что это не так.


