Новый виток истории: однажды я доверил сборку компилятору. Теперь положиться на LLM?

Я выучил ассемблер задолго до C. Тогда я гнался за каждым тактом: переиспользовал регистры по битам, писал XOR A вместо загрузки нуля — словом, делал все, чтобы код был быстрее и компактнее.
Когда я наконец взялся за C, я не доверял компилятору. Неужели он правда выдает самый быстрый и плотный код? Я запускал его с флагом -S и читал сгенерированный ассемблер. Он был идеален. Каждый трюк, которым я гордился: переиспользование регистров, XOR A, компилятор делал по умолчанию. В тот день я и перестал писать на ассемблере.
Об этом на прошлых выходных мне напомнили два поста в сети. Арпит Бхаяни написал, что отныне ни один человек не напишет код лучше LLM, и с этим надо смириться. Пост набрал около 14 тысяч лайков. В тот же день Мэтт Покок заявил, что к разработчикам появятся новые требования, а именно создать специальный язык для ИИ-агентов, чтобы тот был быстрым, как Rust, давал так же мало свободы в дизайне, как Go, и имел максимально строгую систему типов и верификации.
По сути, это два аспекта одного сдвига в сторону нейросетей. В скорости и объеме мы им уже проиграли. Теперь вопрос в том, как направлять этот вывод и как его проверять.
Признаюсь, мне немного грустно, и я понимаю, почему многие инженеры сопротивляются. Но мне кажется, что переход от ассемблера к C начинался с того же спора: «А можем ли мы доверить это компилятору?».
Компилятор не играет в угадайку
Частое возражение против аналогии с компилятором — что он никогда не угадывает, а следует строгим правилам и превращает точную логику в машинный код. Если программа компилируется, она делает то, что мы ей велели.
С LLM все иначе: один и тот же запрос к задаче может дать две разные реализации. Одна может работать, другая — приносить скрытые баги. Получается, мы добавили не стабильный слой абстракции, а игральную кость, которую приходится постоянно перепроверять.
Но есть нюанс. Компиляторы не всегда были такими предсказуемыми. Участник дискуссии, работавший с первыми компиляторами, заметил: поначалу ассемблер только в теории был идеальным. Многие годы компиляторы ошибались, им не доверяли. Потребовались тестовые наборы, стабильные ABI, поколения исправленных багов, чтобы доверие перешло от самого инструмента к слою проверки вокруг него.
Так, поверхность отказа сместилась туда, где ее можно проверить, и проверки начали ловить ошибки. Сегодня мало кто читает вывод -S не потому, что компиляторы стали безупречны, а потому, что системы вокруг них поглотили их баги.
Что на самом деле заменяет LLM
Есть еще один контраргумент: LLM заменяет не детерминированный процесс, а человека. Компиляторы никуда не делись. Мы заменяем нижние уровни разработки, где и раньше работал человек — недетерминированный по своей природе. Разница в том, что теперь мы оборачиваем результат в циклы обратной связи, чтобы убедиться в достижении цели.
Важный момент: у компилятора есть карта соответствия между исходным кодом и скомпилированным. Вы можете проследить, почему программа ведет себя так или иначе, и вернуться к исходнику за ответом. У LLM такой карты нет. Если что-то работает не так, вам придется заново изучать промпт и спецификацию, а иногда и просто угадывать, что менять, потому что между спецификацией и кодом нет прозрачной связи.
Это существенное ограничение, но оно не отменяет главного: вопрос не в том, детерминирован ли инструмент, а в том, проявляются ли отказы там, где вы можете на них отреагировать. Постройте слой, который делает их видимыми, и доверие придет по расписанию.
Практический вывод: проверяйте, а не надейтесь
Что это значит для тех, кто уже использует LLM для написания кода?
Во-первых, перестаньте требовать от модели детерминизма. Вместо этого стройте проверки, которые ловят расхождения. Сравнение результатов «строка в строку» между старой и новой реализацией — именно такой слой. Вы не доверяете агенту, вы доверяете сравнению.
Во-вторых, используйте строгие линтеры и компиляторы с максимально жесткими настройками. Участник обсуждения заметил, что сделать язык «быстрым, как Rust, и с малым простором для дизайна, как Go» уже достижимо — просто используйте Rust с жесткими конфигурациями. Это касается и TypeScript. Я бы не терпел такой строгости, если бы писал сам, но ИИ готов снова и снова проходить циклы, чтобы удовлетворить педантичный линтер.
В-третьих, относитесь к LLM как к стажеру с трехмесячным опытом и доступом к Google. Ему можно поручить простой код, но сложные низкоуровневые задачи пока вне его возможностей. Один из участников с большим стажем заметил, что модели, обученные на специализированных данных, могут писать на удивление хороший ассемблер, а универсальные — вряд ли. Чем ближе язык к человеческому, тем лучше LLM справляется.
Чему учит история компиляторов
Не знаю, чем закончится нынешний переход, но история компиляторов подсказывает: технология может стать мейнстримом задолго до того, как ее перестанут бояться. Один из ветеранов отрасли вывел формулу: «уровень n+1 всегда встречают с недоверием». Компиляторы не «победили» — программисты просто перешли к следующему уровню и начали не доверять реляционным базам данных, 4GL, TCP/IP. Внимание переключалось на недостатки новой блестящей вещи, а технология тем временем взрослела.
Возможно, с LLM будет так же, и однажды я перестану читать каждый сгенерированный дифф. Не потому, что модели станут идеальными, а потому, что вокруг них появится слой проверки, которому я смогу доверять так же, как когда-то доверил компилятору.

Комментарии к статье
Мне интересно, как это повлияет на обучение новичков. Раньше приходилось самому разбираться с каждой ошибкой, а теперь можно просто попросить ИИ все исправить. Удобно, но понимания от этого не всегда прибавляется