Кто отвечает за AI-код: ревью в эпоху быстрой генерации
Текст написан с позиции сентября 2025 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Есть изменения, которые не выглядят как событие. Не вышел громкий релиз, не появилась новая парадигма, никто не объявил конец старого мира. Просто в какой-то момент я заметил, что половина PR, которые приходят на ревью, частично сгенерирована. Не целиком — никто в здравом уме в сентябре 2025 года не мёржит автономно собранную фичу без участия человека, — но фрагментами: функция здесь, тест там, обработка ошибок, которую агент дописал по подсказке. И вот этот тихий сдвиг оказался куда важнее любого анонса. Потому что он поменял не количество кода, а то, что вообще значит «проверить код».
Самая вредная реакция на эту ситуацию — услышать «AI пишет код» и решить, что ревью теперь нужно меньше. Логика кажется убедительной: раз генератор обучен на миллионах строк, раз он редко допускает синтаксические ошибки и обычно соблюдает стиль, значит, человек на выходе может расслабиться и проверять реже. На практике всё наоборот. Ревью нужно не меньше, а другое. И это ключевая мысль, вокруг которой я хочу выстроить весь разговор: ответственность за код не делегируется генератору — она целиком остаётся на человеке, который нажал «мёрж».
В этой статье я хочу разобрать предметно, как меняется процесс code review, когда быстрая генерация становится частью ежедневного workflow. Не на уровне лозунгов, а на уровне конкретных вещей: что проверять стало не так важно, что стало важнее в разы, почему ревью превращается в узкое место и почему это нормальная, здоровая цена скорости, а не баг процесса.
Раньше мы проверяли усилие, теперь проверяем намерение
Чтобы понять, что именно сломалось, полезно вспомнить, на каких неявных допущениях держался обычный code review. Когда код писал человек, ревью опиралось на одну скрытую гарантию: автор хотя бы один раз провёл каждую строчку через голову. Он мог ошибиться, не учесть edge-кейс, выбрать неудачное имя — но сам факт того, что он набирал этот код руками, означал, что у текста есть осмысленное происхождение. За каждой строкой стояло человеческое намерение.
Сгенерированный фрагмент этой гарантии не даёт. Он синтаксически чистый, часто стилистически аккуратный, нередко даже снабжён комментариями. Но за ним не стоит того же объёма продуманности. Агент выдал статистически правдоподобный текст под формулировку задачи — и правдоподобность здесь коварна, потому что она маскирует отсутствие осмысленности. Код выглядит так, будто кто-то о нём подумал, хотя на самом деле о нём ещё никто толком не думал.
Поэтому фокус ревью сместился. Раньше значительная часть внимания уходила на поверхность: форматирование, именование, локальная читаемость, мелкие стилистические придирки. Эту работу давно частично сняли линтеры и форматтеры, а теперь и генерация выдаёт код, который проходит стилевые проверки почти всегда. Тратить ревью на стиль AI-кода — это проверять ровно то, в чём машина и так сильна, и пропускать то, в чём она слаба. Не стиль теперь главное, а намерение: действительно ли этот код решает ту задачу, которую мы ставили, и понимает ли её автор PR так же, как понимает её ревьюер.
Четыре вещи, которые AI-код требует проверять жёстче обычного
Если приземлить всё до конкретики, то AI-фрагмент опаснее человеческого ровно в тех местах, где статистическая правдоподобность расходится с реальной корректностью. Я бы выделил четыре зоны, на которые ревью теперь обязано смотреть пристальнее, чем на код, написанный руками.
- Edge-кейсы и границы. Генератор уверенно покрывает счастливый путь, потому что счастливый путь чаще всего встречается в обучающих данных. А вот пустой массив, null в середине цепочки, гонка двух запросов, переполнение, обрыв соединения на половине ответа — здесь он регулярно выдаёт код, который «обычно работает». Именно «обычно» и есть проблема: в продакшене раз в неделю наступает то самое необычное.
- Безопасность. Сгенерированный код спокойно конкатенирует строку в SQL-запрос, логирует то, что логировать нельзя, доверяет входным данным, забывает про экранирование, подтягивает зависимость с похожим, но не тем именем. Это не злой умысел — это отражение того, что в данных, на которых учили модель, небезопасных примеров полно. Ревьюер теперь обязан смотреть на код глазами того, кто ищет дыру, а не того, кто проверяет аккуратность.
- Согласие с архитектурой. Агент не знает ваших договорённостей. Он не в курсе, что в этом проекте работа с датами идёт через один модуль, что прямые обращения к базе в слое контроллеров запрещены, что у вас есть свой слой для HTTP. Он напишет локально разумный код, который противоречит общему устройству системы. По отдельности каждый такой фрагмент безобиден — все вместе они за полгода размывают архитектуру до состояния, в котором её уже не собрать обратно.
- Скрытые допущения и галлюцинации API. Генерация иногда вызывает методы, которых нет, передаёт параметры, которых функция не принимает, опирается на поведение библиотеки, которое было верно две версии назад. Часть этого ловит компилятор и тесты, но не всё — особенно в динамических языках и на стыке с внешними сервисами.
Объединяет эти четыре пункта одно: их невозможно проверить, читая код как текст. Их можно проверить, только удерживая в голове модель того, что система должна делать, и сверяя предложенный код с этой моделью. Это ровно та работа, которую нельзя сгенерировать, потому что она и есть понимание.
Автор PR обязан понимать каждую строку, которую он принёс
Здесь возникает развилка, на которой команды расходятся. Один путь — считать, что раз код сгенерирован, то и спрос с автора PR мягче: ну, агент так написал, ревьюер разберётся. Это тупиковый путь, и его надо закрывать сразу. Если автор не может объяснить, почему его код устроен именно так, почему здесь стоит эта проверка, а здесь её нет, что произойдёт при пустом вводе — значит, он принёс на ревью не работу, а черновик, который сам не прочитал.
Я сформулировал для себя простое правило, и оно неплохо приживается в команде: автор PR несёт за сгенерированный код ровно ту же ответственность, что и за написанный руками. Не «AI предложил» — а «я выбрал это принести». Происхождение строки не меняет того, кто за неё отвечает. Это сдвигает нагрузку на правильное место. Не ревьюер должен расшифровывать чужую генерацию — автор должен прийти с кодом, который он понял и за который готов отвечать.
Побочный эффект этого правила приятный: оно естественно гасит соблазн заваливать ревью объёмом. Когда сгенерировать тысячу строк стало дёшево, появляется искушение так и делать. Но если за каждую строку придётся отвечать на ревью, человек быстро понимает, что дешевизна генерации не отменяет дороговизны понимания. И начинает приносить меньше, но осмысленнее.
Можно ли поручить ревью второму агенту?
К сентябрю 2025 года вокруг ревью выросла приличная инфраструктура. Агенты умеют не только писать, но и просматривать диффы, оставлять комментарии, предлагать правки. Через MCP мы подключаем их к репозиторию, к трекеру задач, к документации — и они уже способны учитывать контекст проекта куда лучше, чем год назад. Соблазн напрашивается сам собой: пусть один агент пишет, другой ревьюит, человек только утверждает.
Здесь важно не свалиться в другую крайность. AI-ревьюер реально полезен на нижнем слое: он быстро находит типовые баги, замечает забытую обработку ошибки, подсвечивает подозрительные места, напоминает про тест. Как первый проход — отлично, это снимает с человека рутину и экономит его внимание для важного. Но первый проход не равен последнему слову. Агент, который проверяет код, страдает ровно теми же слепыми зонами, что и агент, который его пишет: правдоподобное он пропустит, потому что оно правдоподобное. Два статистических процесса, согласные друг с другом, — это не две независимые проверки, а одна и та же, проведённая дважды.
Поэтому грань я провожу так: инструмент может найти проблему, но не может взять на себя ответственность за её отсутствие. Машина способна сказать «вот тут, кажется, баг». Она не способна сказать «я отвечаю за то, что багов больше нет» — потому что отвечать перед командой, перед пользователем, перед собой через полгода может только человек. Подпись под мёржем — это не технический акт, это акт принятия ответственности. И его нельзя автоматизировать, не потеряв сам смысл слова «ответственность».
Ревью становится узким местом — и это нормально
Прямое следствие всего сказанного неприятно, но честно его проговорить нужно. Если генерация кода ускорилась в несколько раз, а понимание кода человеком — нет, то ревью неизбежно становится узким местом пайплайна. Раньше код медленно писали и быстро смотрели. Теперь код быстро пишут и медленно смотрят. Бутылочное горлышко переехало, и переехало оно на самый ценный и наименее масштабируемый ресурс — на внимание квалифицированного инженера.
Первая реакция многих команд — воспринять это как поломку, которую надо срочно чинить: ускорить ревью, ослабить требования, пропускать «очевидное», доверять зелёному CI. Я считаю это ошибкой. Узкое место в ревью — не баг процесса, а его честное место равновесия. Это не сбой, а цена скорости, и цена эта здоровая. Система, в которой генерация дешёвая, а проверка дешёвая, — это система, которая просто накапливает непонятый код, и счёт по нему придёт позже, с процентами.
Не «ревью тормозит нас», а «ревью — это последнее место, где скорость встречается с ответственностью». Если убрать это сопротивление, исчезнет не задержка, а гарантия. Поэтому правильная цель — не устранить узкое место, а сделать его осознанным: понимать, что именно тут система платит за быстроту генерации, и платить эту цену сознательно, а не пытаться от неё сбежать.
Как мы перестроили процесс на практике
Из всего этого выросло несколько изменений в том, как команда устроила ревью. Они не революционные — скорее это аккуратная настройка процесса под новую реальность, в которой происхождение кода стало неоднородным.
- Мы стали резать PR мельче. Если сгенерировать много легко, то дисциплина маленьких изменений важнее, чем когда-либо: маленький PR можно по-настоящему понять, большой — только бегло просмотреть, а беглый просмотр AI-кода почти бесполезен.
- Мы договорились, что описание PR содержит намерение, а не пересказ диффа. Не «добавил функцию X», а «решаю задачу Y, выбрал такой подход, потому что…, а вот что я сознательно не покрыл». Это возвращает в процесс то самое человеческое происхождение, которого генерация не даёт.
- Мы перестали тратить время людей на стиль. Форматирование, именование, типовые придирки — это к линтеру и к автоматике. Внимание ревьюера дорого, и оно уходит на edge-кейсы, безопасность и архитектуру, а не на то, где машина и так не ошибается.
- Мы используем AI-ревью как первый проход, но не как зелёный свет. Его комментарии — вход для человека, а не замена ему. Утверждение PR по-прежнему делает инженер, и именно он отвечает за результат.
Отдельно стоит сказать про тесты. Соблазн принять сгенерированные тесты как доказательство корректности очень велик — они зелёные, их много, они выглядят солидно. Но тест, написанный тем же процессом, что и код, часто проверяет ровно то, что код и так делает, включая его ошибки. Такой тест фиксирует поведение, а не требование. Поэтому к AI-тестам мы относимся как к коду: они тоже проходят ревью, и в первую очередь мы смотрим, проверяют ли они то, что мы реально хотим, а не то, что удобно проверить.
За скорость генерации платит внимание инженера
Будет нечестно закончить на ноте «мы всё придумали, теперь работает». У нового процесса есть своя цена, и её надо назвать прямо. Ревью стало требовательнее к людям. От ревьюера теперь нужна не аккуратность чтения, а глубина понимания системы — а это более редкий навык, и расходует он человека заметно быстрее. Внимание расходуется быстрее, потому что приходится постоянно держать в голове вопрос «а правда ли автор это понял, или просто принёс правдоподобное».
Растёт и нагрузка на старших инженеров. Именно они держат в голове архитектуру и именно они замечают, что локально разумный сгенерированный фрагмент противоречит общему устройству. Если не распределять эту работу осознанно, ревью превращается в персональное бутылочное горлышко на нескольких людях, и они выгорят первыми. Это реальный риск, а не теоретический, и его нельзя замолчать ради красивого вывода.
Так что никакого «магически всё решено» здесь нет. Быстрая генерация не убрала из инженерной работы дисциплину — она сделала дисциплину дороже и заметнее. То, что раньше было размазано по медленному написанию кода, теперь сконцентрировалось в точке ревью. Это не упрощение профессии, а её взросление: меньше времени на набор текста, больше времени на ответственность за смысл.
Меняется не объём ревью, а его природа
Когда половина PR частично сгенерирована, меняется не объём работы ревьюера, а её природа. Мы перестаём проверять, как код написан, и начинаем проверять, что он значит: совпадает ли намерение автора с задачей, покрыты ли границы, нет ли дыр в безопасности, согласуется ли решение с архитектурой системы. Стиль уходит к автоматике, понимание остаётся за человеком — и именно понимание теперь дефицит.
Инструменты в этом помогают, и помогают всё лучше: агенты делают первый проход, MCP подтягивает контекст, рутинные баги отлавливаются быстрее. Но ни один из этих слоёв не снимает с человека финального решения. Генератор предлагает — отвечает тот, кто принял. Подпись под мёржем не автоматизируется, потому что автоматизировать можно действие, но не ответственность за его последствия.
А узкое место в ревью стоит не чинить, а принять. Это не поломка ускорившегося процесса, а место, где он честно платит за свою скорость. Если сформулировать совсем прямо: AI ускорил написание кода, но не написание ответственности за него — и пока это так, последним и решающим звеном остаётся человек, который понял то, что мёржит.