Если агент пишет код в вашем репозитории, однажды вы ловите себя на странном занятии. Открываете pull request и вместо построчного чтения ищете, где там могла быть принята неочевидная идея. Потом ловите себя ещё раз: тесты зелёные, имена нормальные, код чистый. Читать дальше как будто нечего.
У меня так вышло на небольшом встроенном проекте на C. Агент писал код, местами с паттернами, которых я раньше не использовал. Сначала я вёл себя как на продакшене: маленькие pull request, каждый прочитан построчно. Потом заметил, что код хороший, и перешёл на тесты. Потом — на вопросы. Почему выбрана такая архитектура и такой порядок, что будет, если соединение оборвётся на середине. Если одно и то же сообщение придёт дважды. Я проверял ответы. Они сходились. Каждый раз.
Вот тут и начинается неприятная часть. Я не помню, когда последний раз смотрел, что выдаёт компилятор. На этом проекте я незаметно начал так же относиться к агенту. Хорошо это или нет — вопрос не про качество модели. Он про то, что именно вы проверяете и кто делает эту работу, если не вы.
Дифф проигрывает по скорости
За лето число изменений в моих репозиториях выросло больше чем вдвое. Медианное изменение при этом держалось около 35 добавленных строк. Маленькие шаги помогали читать каждый отдельный diff. Они не помогали читать общий поток.
Арифметика простая. Агент делает чистое изменение за несколько минут. У меня нормальное чтение занимает минут десять. Соотношение уходит в одну сторону. Можно ускоряться, можно читать выборочно, можно делать вид, что «просмотрел достаточно». Дифф от этого не становится местом, где вы ловите главные ошибки.
И ещё одна вещь. Самый дорогой дефект в моей серии статей был не в диффе. Двадцать чистых изменений в шаге дедупликации несли одно неверное допущение четырнадцать месяцев. Я перечитал изменение, которое должно было это поймать, и не нашёл к чему придраться. Ревью диффа было уровнем, на котором я силён. Проблема была не на этом уровне.
Агент — не компилятор
Соблазн назвать агента следующим компилятором был и у меня. Аналогия почти держится. Почти.
Обычное возражение — детерминизм. Компилятор на один и тот же исходник выдаёт один и тот же результат. Агент на один и тот же промпт может выдать две разные программы. Это правда. И это менее важно, чем кажется.
Компилятор ничего не решает. Исходный код — полная спецификация программы: каждое поведение в нём описано, компилятор только переводит. Промпт, план, двухчасовая сессия с агентом — не полная спецификация. Большая часть того, что попадает в код, никогда не проговаривалась. Агент заполняет пробелы. Каждый заполненный пробел — решение.
Пример: в задаче с дедупликацией никто не просил, чтобы запись из федерального регистра и запись из роуминговой сети несли одно и то же имя оператора. Агенту нужна была пара записей. Он её написал. Написать пару — значит решить, как выглядит настоящая пара. Он решил неверно и при этом разумно. Детерминированный агент принял бы то же решение на каждом запуске. Воспроизводимо ошибаться — не улучшение.
Компилятор переводит. Агент переводит и решает, и не говорит, где какое.
Почему компилятору доверяют, а агенту пока нет
Доверие к компиляторам не появилось само. Его строили десятилетиями. Когда IBM в 1957 году выпускала первый компилятор Fortran, команда ожидала, что программисты отвергнут его, если сгенерированный код не будет работать почти так же быстро, как рукописный ассемблер. На это ушло много сил.
Компиляторы до сих пор не идеальны. Исследователи из Университета Юты три года скармливали случайные C-программы мейнстримным компиляторам, включая GCC и LLVM, и нашли больше 325 неизвестных багов. Каждый протестированный компилятор можно было заставить упасть. Каждый тихо выдавал неверный код на валидном входе. В лекции 1984 года Кен Томпсон показал, что компилятор может спрятать бэкдор, которого нет ни в одном исходнике, и закончил жёстко: «Вы не можете доверять коду, который не создали полностью сами».
И всё равно мы доверяем. Потому что кто-то другой проверяет: спецификации языка, большие наборы тестов, фаззеры вроде того, что был в Юте, миллионы программ, которые сломаются громко, если компилятор ошибётся. Я не читаю ассемблер, потому что эту работу где-то делает кто-то другой. Не я. С агентами мне как раз не хватало этого «кого-то другого».
| Что сравниваем | Компилятор | ИИ-агент |
|---|---|---|
| Вход | Полный исходный код | Промпт, план, сессия; часть решений не проговорена |
| Что делает | Переводит | Переводит и заполняет пробелы допущениями |
| Повторяемость | Один исходник — один результат | Один промпт — разные программы; детерминизм не убирает неверные допущения |
| Кто проверяет | Спецификации, тесты, фаззеры, чужие программы | Второй ревьюер, тесты и ваши вопросы; допущения часто остаются невидимыми |
Что делать вместо построчного чтения
Если вы перестаёте читать дифф, должны случиться две вещи. Перевод должен проверять кто-то другой. А решения должны стать видимыми, потому что именно они остаются предметом вашего ревью.
Просите список допущений. В конце сессии попросите агента перечислить всё, что он предположил без вашего указания: о данных, о вызывающем коде, о том, что можно безопасно игнорировать. Список обычно короткий. В нём часто есть ровно один пункт, с которым вы бы не согласились. С этого списка и начинайте ревью.
Выбирайте изменения случайно. Одно из десяти, выбранное не по «риску», а наугад. Читайте по-старому: в IDE, рядом с сессией, построчно. Если описание и код расходятся, доверие падает, и какое-то время читайте всё. Так работает аудитор. Заодно руки не забывают ремесло.
Держите второго ревьюера. У меня каждый pull request дополнительно смотрит другая модель, GitHub Copilot. Она находит больше меня. С более новыми моделями, которые пишут код, находит всё меньше. Остаются странные краевые случаи: несколько маловероятных событий в неудачном порядке. Это не те ошибки, которые я ловил раньше — неверное условие цикла или счётчик, съехавший на единицу. Такие я больше не вижу. Похоже, другой модели уже можно отдать роль лучшего ревьюера. По крайней мере, в моём случае.
Оставляйте решение за собой. После находки остаётся вопрос: стоит ли это чинить? Часто нет. Настоящее исправление редкой гонки может добавить блокировку, состояние и путь повторной попытки. Сложность обойдётся дороже, чем сама гонка. Дешёвый вариант — обнаружить случай и упасть с понятной ошибкой. Это решение, и оно приходит из опыта жизни со сложностью, которая не окупилась.
Когда такой подход не подходит
- В коде есть предметная логика, которой нет в сессии: правила рынка, договорённости между системами, странности данных. Агент не знает, что федеральный регистр и роуминг никогда не называют оператора одинаково. Пока вы это не записали, он будет угадывать.
- Цена ошибки высока, а внешней проверки нет. Если неверное допущение тихо живёт в проде месяцами, выборочного чтения мало. Нужен полный разбор решений и данных.
- Вы сами ещё не понимаете задачу. Агенту придётся заполнять слишком много пробелов. Сначала сформулируйте, что считается правильным результатом, потом отдавайте код.
Что остаётся
Дифф не исчезает. Он перестаёт быть главным уровнем проверки. Навык читать код и чувствовать, где что-то не так, уходит туда же, куда ушло чтение шестнадцатеричных дампов. Это не трагедия. Но уровень выше требует других знаний: что два источника никогда не совпадут в названии, что комментарий капсом — предупреждение, что придуманная кем-то фикстура ничего не доказывает про реальный мир.
Часть этого пришла из написания кода. Большая часть — из моментов, когда мир отказывался совпадать с кодом, который я написал. Научит ли сборка с агентом этой второй части, я пока не знаю. Наблюдаю.
Пока вывод простой. Перевод можно доверить проверке. Решения придётся оставить себе. И искать дорогие ошибки там, где они всегда были: в допущениях, которые никто не заметил, что принимает.
Комментарии (1)
Войдите, чтобы комментировать.