AI разобрался в чужом легаси за полчаса. Это его лучшая работа

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

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

Я долго относился к большим языковым моделям как к инструменту, который всем продают раньше, чем он заслужил доверие. Генерация кода меня скорее раздражала: модель уверенно писала функцию, которая выглядела правильной, проходила беглый взгляд и разваливалась на третьем граничном случае. Я тратил на проверку почти столько же, сколько сэкономил на написании, а иногда и больше. Поэтому к осени 2024 года мой скепсис не был позой. Это был вывод из практики: там, где цена ошибки высокая, помощник, который ошибается уверенно, опаснее, чем полезен.

А потом случилась банальная рабочая ситуация. Мне отдали чужой модуль — несколько тысяч строк, написанных человеком, который уже год как ушёл из компании. Ни внятного README, ни комментариев, ни тестов. Классика легаси: код работает, его боятся трогать, и никто не помнит, почему он устроен именно так. Я открыл файл, посмотрел на портянку из вложенных колбэков, мутаций и хитрых условий, вздохнул и от усталости, а не от веры, закинул его целиком в чат с моделью. Спросил буквально: «что тут происходит, какие зависимости, какие есть неочевидные допущения».

Через полминуты я получил карту местности. Не идеальную, с парой неточностей, но именно карту: основные ответственности модуля, ключевые точки входа, какие части стора он читает, где у него скрытое состояние, где он молча полагается на порядок вызовов, и три места, которые модель честно отметила как «подозрительные, нужно проверить вручную». То, на что у меня в одиночку ушло бы полдня вдумчивого чтения, я получил как черновик за время, пока остывает кофе. И вот тогда я впервые поймал себя на мысли, что нашёл сценарий, где этот инструмент стабильно полезен даже мне.

Главное наблюдение, к которому я пришёл, звучит так: AI силён не там, где задача — решить, а там, где задача — понять, потому что цена ошибки в объяснении принципиально ниже, чем цена ошибки в сгенерированном коде. Это и есть та граница, вдоль которой проходит вся остальная статья.

Объяснение — это гипотеза, а сгенерированный код — уже действие

Когда я прошу модель написать код, я отдаю ей право на действие. Её вывод попадёт в систему, будет исполняться, повлияет на пользователей. Любая галлюцинация здесь — это потенциальный баг, который мне же потом ловить. Ответственность за корректность целиком на выходе модели, а проверять сгенерированный код по-настоящему дорого: чтобы убедиться, что функция верна, мне нужно фактически воспроизвести логику у себя в голове, то есть проделать ту же работу, которую я якобы делегировал.

Когда я прошу модель объяснить незнакомый код, расклад принципиально другой. Её вывод — не действие, а гипотеза. Он ничего не ломает сам по себе. Он лишь направляет моё внимание. Если объяснение в чём-то ошибочно, ошибка всплывёт ровно в тот момент, когда я начну сверять её с исходником, который лежит прямо передо мной. У меня под рукой источник правды — сам код. Объяснение работает как навигатор по этому источнику, а не как замена ему.

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

Онбординг в чужой код — это в основном работа по чтению, а не по письму

Если честно посмотреть, на что уходит время при погружении в незнакомую кодовую базу, окажется, что почти всё это — чтение и реконструкция. Я не пишу новый код первые часы. Я выясняю, какие модули за что отвечают, кто кого вызывает, где живёт состояние, какие соглашения приняты в проекте, где проходят границы слоёв. Это утомительная археология: открыть файл, проследить импорт, прыгнуть в следующий, вернуться, потерять нить, начать заново.

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

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

Что конкретно я спрашиваю у модели про незнакомый модуль

За эти недели у меня сложился набор вопросов, который стабильно даёт полезный результат. Я перечислю их, потому что формулировка вопроса здесь решает почти всё:

  • Какова основная ответственность этого модуля, если описать её в двух предложениях?
  • Какие у него внешние зависимости и что он импортирует из других частей проекта?
  • Где здесь хранится состояние и какое из него является скрытым или неочевидным?
  • Есть ли неявные допущения: порядок вызовов, обязательная инициализация, побочные эффекты?
  • Какие участки выглядят как кандидаты на баг или на устаревший код, который уже не используется?
  • Если бы мне нужно было это покрыть тестами, с каких сценариев логичнее всего начать?

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

Отдельно хорошо работает связка из двух шагов. Сначала прошу высокоуровневое описание, чтобы получить общую форму. Потом тыкаю в конкретную функцию и прошу разобрать её построчно: что делает этот тернарник, почему здесь проверка на null, что вернётся в краевом случае. Сверху вниз я получаю карту, снизу вверх — детали. Между этими двумя проходами как раз и набирается то понимание, ради которого всё затевалось.

Что сдвинулось к осени 2024: не ум модели, а размер контекста

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

К лету 2024 это ощутимо сдвинулось. Claude 3.5 Sonnet, вышедший в июне, и GPT-4o заметно подняли планку по качеству рассуждения о коде, а окна контекста в 128–200 тысяч токенов из диковинки стали нормой. Появилась возможность дать модели не фрагмент, а связный кусок системы и получить ответ, который учитывает её целиком. Параллельно редакторы вроде Cursor начали встраивать это прямо в рабочий процесс: подсветить участок, спросить «что это делает», получить разбор, не выходя из файла. Трение между вопросом и ответом упало почти до нуля.

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

Тем же ровным тоном модель объяснит и то, чего в коде нет

Теперь о цене, потому что без неё этот текст превратился бы в рекламу, а писать рекламу я не собирался. Модель уверенно ошибается и в режиме объяснения тоже. Она может приписать функции назначение, которого у той нет, потому что имя переменной её к этому подтолкнуло. Она может объявить кусок кода мёртвым, хотя он дёргается из места, которое я ей не показал. Она может уверенно описать поток данных, который на одну стрелку не совпадает с реальностью. И сделает это тем же ровным, убедительным тоном, что и верные утверждения.

Особенно коварны два случая. Первый — скрытые зависимости за пределами показанного контекста. Если модуль молча опирается на глобальное состояние, на side effect из соседнего файла или на порядок инициализации, которого нет в тексте перед моделью, её карта будет уверенной и неполной одновременно. Второй — динамика. Статический текст плохо рассказывает о том, что происходит в рантайме: какие значения реально приходят, как часто срабатывает ветка, что бывает под нагрузкой. Здесь модель предполагает, а не знает, и иногда выдаёт предположение за факт.

Поэтому правило, которое я для себя вывел, простое и жёсткое: объяснение модели — это стартовая карта местности, а не территория. Карте можно доверить выбор направления. Нельзя доверить ей утверждение, что за поворотом точно нет обрыва. Каждую гипотезу, на которой я собираюсь строить изменение, я подтверждаю по исходнику, по дебаггеру или по тесту. Модель экономит мне дорогу к нужному месту, но решение, что там действительно так, остаётся за мной.

Проверить готовую гипотезу дешевле, чем родить её с нуля

Можно было бы заключить, что раз объяснениям нельзя верить слепо, то и польза сомнительна. Это была бы самая вредная реакция на всю историю — услышать про неточности и решить, что инструмент бесполезен. На деле экономия реальная, и вот почему: проверять конкретную гипотезу гораздо дешевле, чем строить её с нуля.

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

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

На статическом тексте инструмент выигрывает, на живом рантайме — слепнет

Чтобы не сваливаться в крайность всеобщего применения, стоит очертить зоны. Сценарий «дай мне понять этот код» почти наверняка окупается в нескольких ситуациях. Когда вы пришли в новый проект и тонете в чужих соглашениях. Когда нужно быстро оценить незнакомую библиотеку или модуль перед тем, как решить, использовать его или нет. Когда разбираете легаси без документации и тестов. Когда делаете code review большого незнакомого pull request и хотите сначала схватить общую форму изменений, прежде чем нырять в детали.

И наоборот, есть зоны, где я бы на это не полагался. Там, где код опирается на динамику рантайма, конкурентность, гонки, тайминги — статичный разбор текста принципиально слеп. Там, где речь о безопасности и корректность критична до последней детали, объяснение модели — повод присмотреться, а не основание для вывода. И там, где контекст физически не помещается целиком: если модуль молча завязан на половину системы, частичная картина опаснее отсутствия картины, потому что создаёт ложное чувство ясности.

Граница между этими зонами проходит ровно по тому же признаку, что и в начале статьи. Где задача — понять структуру статического текста, инструмент силён. Где задача — гарантировать поведение живой системы, он лишь подсказчик. Не перепутать эти два режима — это и есть та самая инженерная зрелость, которой требует работа с любым новым инструментом.

Как это меняет привычку, а не профессию

Я заметил, что после нескольких недель такого использования у меня поменялась не профессия, а одна конкретная привычка. Раньше, открывая страшный незнакомый файл, я внутренне готовился к долгому погружению, откладывал его, искал предлог заняться чем-то понятным. Теперь первый шаг стал дешёвым: закинуть, спросить, получить грубую карту, и уже от неё начинать осознанное чтение. Психологический барьер на входе в чужой код заметно опустился.

Это, пожалуй, и есть самый недооценённый эффект. Дело не в том, что я стал быстрее читать код. Дело в том, что я перестал откладывать неприятную часть работы, потому что она перестала быть такой неприятной. А отложенное чтение чужого легаси — это источник огромного объёма технического долга и «давайте лучше перепишем, чем разбираться». Иногда дешевле всё-таки разобраться, и теперь у этого «разобраться» появилась нормальная отправная точка.

При этом ответственность за итоговое понимание никуда не делась. Я по-прежнему обязан знать, как работает код, который трогаю. Просто путь к этому знанию стал короче на самую утомительную свою часть. Это не подмена понимания, а ускорение подхода к нему. Граница тонкая, но держать её — обязанность инженера, а не модели.

Навигатор по чужой территории, а не автор решений

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

Работает это именно потому, что задача понять устроена иначе, чем задача решить. Объяснение — это гипотеза, которую я проверяю по лежащему передо мной источнику, а не действие, которое незаметно попадает в систему. Цена ошибки в объяснении низкая, цена ошибки в генерации высокая, и вся практическая польза держится на этой асимметрии. Поэтому я не доверяю модели слепо даже в её сильной роли: карта помогает выбрать путь, но проверять, есть ли за поворотом обрыв, всё равно мне.

Лучшая работа AI в коде на сегодня — не написать за тебя, а помочь тебе понять; и пока ты относишься к его объяснениям как к стартовой карте, а не как к территории, это перестаёт быть хайпом и становится обычным, честным инструментом, который экономит часы даже скептику.

Автор

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

Обновлено

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