Маленький junior внутри: почему AI-код нельзя мёржить не глядя

•
Опубликовано
•
10 мин чтения

Текст написан с позиции марта 2024 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

За последние месяцы что-то незаметно сдвинулось в самом обыденном слое разработки. Раньше в pull request попадал код, который человек писал руками, путаясь, гугля, спотыкаясь и оставляя следы своих сомнений в комментариях. Теперь в ревью все чаще приходит код другого рода: ровный, аккуратный, синтаксически безупречный, с правильными именами переменных и причесанными отступами. И на первый взгляд это выглядит как прогресс. На второй — как новая категория проблем, которую команды пока не научились называть вслух.

Я не пишу это из вредности и не из позиции человека, которому не нравится все новое. GPT-4 Turbo, Copilot, набирающий популярность Cursor — это уже не диковинка, а часть рабочего стола. На днях вышла Claude 3, и судя по первым отзывам, планка генерации поднялась снова. Инструменты реально полезные, и спорить с этим бессмысленно. Я пишу из опыта ревью: за последние недели я слишком часто ловил себя на том, что апрувлю что-то красивое, а потом нахожу в нем тихую дыру, которую человек на этом месте, скорее всего, не оставил бы. И чем дальше, тем яснее становится одна простая мысль, которую хочется зафиксировать сразу.

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

AI-код ведет себя как очень быстрый, очень уверенный и абсолютно безответственный junior

Самая точная метафора, которую я нашел для себя за эти недели, звучит так: внутри каждого такого инструмента сидит маленький junior. Не плохой junior. Наоборот, феноменально способный. Он печатает быстрее любого живого человека, не устает, не раздражается на скучные задачи, помнит синтаксис всех библиотек сразу и почти никогда не делает глупых опечаток. Если бы у меня в команде был человек с такой скоростью набора и таким спокойствием, я бы радовался.

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

Здесь важна не критика, а трезвость. Живой junior тоже ошибается. Разница в том, что ошибки живого junior выглядят как ошибки. Они корявые, видимые, с запахом неуверенности — их легко заметить на ревью, потому что они торчат. Ошибки AI выглядят как зрелый код. Они причесаны, и именно поэтому проскакивают мимо взгляда. Мы привыкли, что плохой код легко опознать по форме. AI ломает эту привычку: форма идеальна, а суть может быть пустой.

Идеальный синтаксис создает ложное ощущение проверенности

Чтобы понять, почему так легко промахнуться на ревью, надо честно описать, как мы вообще читаем чужой код. Мы не верифицируем каждую строку формально. У нас нет на это ни времени, ни сил. Вместо этого мы опираемся на сигналы. Аккуратное форматирование, осмысленные имена, привычные паттерны, отсутствие странностей — все это подсознательно читается как «автор знал, что делал». Мы доверяем форме как косвенному свидетельству качества мысли. Долгие годы это работало, потому что форма и мысль шли рядом: человек, способный написать аккуратно, обычно и думал аккуратно.

AI разрывает эту связку. Он научился производить форму без гарантии мысли. Код выглядит так, будто автор продумал edge-кейсы, хотя он их просто не рассматривал. Имена переменных звучат так, будто за ними стоит доменная модель, хотя модель никто не строил. В результате включается то, что я для себя называю эффектом ложной проверенности: чем красивее сгенерированный фрагмент, тем меньше хочется в него лезть. Мозг ревьюера экономит силы и принимает форму за содержание.

И вот здесь важно быть честным до конца. Проблема не в AI. Проблема в иллюзии, что сгенерированное равно проверенному. Инструмент честно делает свою работу — производит правдоподобный текст. Подмену совершаем мы сами, когда мысленно ставим знак равенства между «выглядит готовым» и «является готовым». AI не обещал нам корректности. Он обещал генерацию. Все ожидания сверх этого — наша проекция, а не его свойство.

Дыры прячутся ровно там, куда форма не заглядывает

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

  • Edge-кейсы. Пустой массив, null там, где ожидался объект, нулевая длина, отрицательное число, строка вместо числа, ответ API без ожидаемого поля. Сгенерированный код почти всегда корректно решает «нормальный» сценарий — тот, что описан в промпте, — и почти всегда игнорирует границы, о которых в промпте не сказали. Junior внутри отвечает ровно на заданный вопрос и не задает встречных.
  • Безопасность. Конкатенация пользовательского ввода в запрос, отсутствие экранирования, доверие к данным с клиента, секреты, прокинутые прямым текстом, потому что так «проще для примера». Инструмент оптимизирует читаемость демонстрации, а не модель угроз. О том, что данные враждебны, он по умолчанию не думает, если его об этом явно не попросить.
  • Обработка ошибок. Часто это либо отсутствующий try/catch, либо, что хуже, проглоченное исключение в пустом блоке. Внешне выглядит как обработка. По сути — как место, где ошибка тихо исчезнет и всплывет где-то совсем в другом месте через неделю.
  • Производительность и побочные эффекты. Лишний запрос в цикле, повторное вычисление, которое легко закэшировать, мутация переданного объекта. По одному фрагменту это незаметно. На масштабе системы складывается в медленную деградацию, которую потом долго ловят профайлером.
  • Контекст вашей системы. Самое неустранимое. AI не знает ваших соглашений, вашего слоя абстракций, причин, по которым в проекте принято делать именно так, а не иначе. Он напишет локально разумный код, который глобально нарушает архитектуру, потому что он не видит архитектуры.

Объединяет все эти пункты одно: ни один из них не виден по форме. Чтобы поймать пустой массив, надо подумать про пустой массив. Чтобы поймать SQL-инъекцию, надо посмотреть на код глазами того, кто хочет его сломать. Чтобы поймать архитектурное нарушение, надо держать в голове всю систему. Ничего из этого AI за вас не делает, и ничего из этого не следует из красоты отступов.

Почему «AI сэкономил время» — это часто бухгалтерская иллюзия

Главный аргумент в пользу того, чтобы коммитить сгенерированное побыстрее, всегда один: экономия времени. И на коротком отрезке это правда. Задача, которая заняла бы сорок минут ручного набора, решается за пять. Ощущение продуктивности при этом почти физическое — ты видишь, как код появляется на глазах, и тебе кажется, что ты движешься быстрее.

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

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

Ревью не дешевеет от того, что код стал генерироваться

Из всего этого вытекает довольно неудобный для многих команд вывод. Если код производится быстрее, то ревью должно стать не легче, а строже. Раньше существовал негласный мысленный шорткат: раз человек это написал руками, значит, он хотя бы один раз об этом подумал. Этот шорткат больше не работает. Факт того, что строка существует, больше ничего не говорит о том, что кто-то осознанно решил ее написать.

Поэтому центр тяжести смещается. Ценность инженера все меньше в том, чтобы произвести код, и все больше в том, чтобы за него отвечать. Подпись под pull request — это не «я набрал эти символы», это «я понимаю, что здесь происходит, и готов жить с последствиями». Если автор не может объяснить, почему код именно такой, что будет при пустом вводе и где здесь граница допустимого, — неважно, написал он это сам или сгенерировал. Код не готов к мёржу. Сгенерированность тут не оправдание и не смягчающее обстоятельство.

Практически это значит, что к AI-коду надо относиться не как к работе коллеги-сеньора, которому можно доверять по умолчанию, а именно как к работе того самого способного, но безответственного junior. Его вклад полезен. Но он проходит через взрослого, который читает каждую строку, задает неудобные вопросы и ставит свою подпись осознанно. Junior предлагает. Решение и ответственность остаются за человеком. Перепутать эти роли — значит снять с системы единственный слой, который держит ее в честности.

Я не предлагаю выключить Copilot — я предлагаю перестать ему верить на слово

Здесь я обязан проговорить цену собственной позиции, иначе она превратится в ту самую вредную крайность, от которой я предостерегаю. Все сказанное — не аргумент за то, чтобы отключить Copilot и запретить генерацию. Это было бы и наивно, и контрпродуктивно. Инструменты слишком полезны на рутине: бойлерплейт, тесты по образцу, преобразования формата, первые наброски, изучение незнакомого API. Отказ от них ради чистоты — это поза, а не инженерия.

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

У этой дисциплины есть цена, и ее не надо скрывать. Внимательное ревью сгенерированного кода стоит времени, и в моменте оно частично съедает ту самую экономию, ради которой все затевалось. Но это честная цена. Она платится сейчас, маленькими порциями, на ревью, а не потом, большим куском, на проде, ночью, под крики о потерянных данных. Выбор не между «быстро» и «медленно». Выбор между «заплатить вниманием сейчас» и «заплатить инцидентом позже». И второе почти всегда дороже.

Что в итоге изменилось при чтении кода

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

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

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также