Claude 3 и гонка моделей: стало лучше, привычки — те же

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

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

За последние пару месяцев гонка языковых моделей заметно разогналась. В марте Anthropic выпустила семейство Claude 3 — три варианта, Opus, Sonnet и Haiku, разнесенные по соотношению «качество против скорости и цены». Параллельно остается актуальным GPT-4 Turbo с расширенным контекстом, а вокруг всего этого растет инструментарий вроде Cursor, который встраивает модель прямо в редактор. Если читать ленту, складывается ощущение, что планка поднялась на ступеньку, и довольно ощутимо. Я с этим не спорю. Ответы действительно стали лучше.

И вот тут хочется зафиксировать сразу, пока разговор не уехал в восторги. Да, модели поумнели. Да, на ряде задач разница между прошлым летом и сегодняшним днем видна невооруженным глазом. Но за эти же месяцы я с удивлением обнаружил, что моя собственная рабочая дисциплина не сдвинулась ни на миллиметр. Я по-прежнему перечитываю каждую сгенерированную строчку. Я по-прежнему не пускаю модель в архитектурные решения. И чем лучше становятся ответы, тем отчетливее я понимаю, что это не временная осторожность, которую прогресс однажды отменит.

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

Что реально изменилось с Claude 3 и почему это не мелочь

Начну честно: прогресс настоящий, и преуменьшать его глупо. Claude 3 Opus на многих задачах рассуждает связнее, дольше удерживает контекст и реже теряет нить в длинном диалоге. Sonnet дает разумный баланс для повседневной работы, а Haiku отвечает быстро и дешево там, где не нужна тяжелая артиллерия. Сам факт, что у модели появилась внятная линейка под разные бюджеты внимания, — это уже признак того, что индустрия перестала продавать «одну волшебную модель на все» и начала думать категориями инструмента под задачу.

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

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

Почему лучшая модель не делегирует ответственность вместе с генерацией

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

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

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

Я по-прежнему перечитываю каждую строчку — и не считаю это пережитком

Самый частый вопрос, который мне задают: зачем вычитывать все, если качество выросло. Раз модель ошибается реже, может, достаточно просматривать по диагонали и доверять. Логика понятна, но она ведет не туда. Дело в том, что вычитка нужна не только чтобы ловить ошибки. Она нужна, чтобы я понимал свой собственный код.

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

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

Архитектуру я модели не отдаю — и причина не в недоверии

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

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

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

На рутине и разборе чужого кода прогресс отбивается сразу

Чтобы не выглядело так, будто я обесцениваю прогресс, приземлю до конкретики, где Claude 3 и его соседи реально меняют мой день. Во-первых, это скорость прохождения рутины. Boilerplate, типовые преобразования, перевод псевдокода в рабочий черновик, объяснение незнакомого API — все это стало быстрее и приятнее. Во-вторых, это разбор чужого кода: скинуть модели запутанный модуль и попросить пересказать, что он делает, — отличный способ сэкономить полчаса вникания.

Полезно собрать это в короткий список, чтобы было видно границу:

  • Генерация черновика реализации по четкому описанию — да, и это стало заметно лучше.
  • Объяснение незнакомого кода или ошибки — да, экономит время на вникание.
  • Рутинные преобразования, boilerplate, типовые тесты — да, тут модель ускоряет работу.
  • Финальная вычитка и понимание кода перед мержем — нет, это по-прежнему на мне.
  • Выбор архитектуры, границ модулей и контрактов между слоями — нет, это решение с подписью.

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

За тотальную вычитку я плачу временем — и это честная цена

Было бы нечестно подать свою дисциплину как бесплатную добродетель. У нее есть цена, и ее стоит назвать. Сплошная вычитка отъедает время. Бывает, что я перечитываю код, в котором при беглом взгляде и так все нормально, и формально это лишние минуты. Есть риск перегнуть и проверять там, где модель давно заслужила базовое доверие на простых задачах. Тотальная подозрительность тоже стоит сил и иногда тормозит там, где можно было бы ехать быстрее.

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

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

Почему мои привычки не зависят от номера версии

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

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

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

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

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

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

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

Автор

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

Обновлено

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