GPT-4o, мультимодальность и почему я всё ещё печатаю руками
Текст написан с позиции мая 2024 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Когда 13 мая OpenAI показала GPT-4o, первое впечатление было почти физическим: стало быстрее. Ответы летят, голосовой режим в демо реагирует почти мгновенно, можно кинуть скриншот ошибки и сразу получить разбор, можно показать камере доску и услышать комментарий вслух. Буква «o» в названии расшифровывается как «omni» — одна модель, которая работает с текстом, изображением и звуком. На сцене это выглядело как скачок в новое качество взаимодействия. И именно потому, что выглядело так убедительно, имеет смысл остановиться и спросить себя трезво: что из этого реально меняет developer workflow, а что — красивое демо для презентации.
Я задаю этот вопрос не из вредности. За последний год я прошёл путь от довольно жёсткого скепсиса к спокойному использованию LLM в работе. GPT-4 и Claude 3 давно лежат у меня в открытой вкладке рядом с редактором, Cursor стоит вторым инструментом для быстрых правок. Скепсис смягчился, но не исчез: он просто стал точнее. И главный вопрос для меня теперь не «умеет ли модель», а «на что именно из её умений можно опереться в реальной кодовой базе, а на что — нет».
С GPT-4o этот вопрос встаёт особенно остро, потому что релиз продаёт прежде всего скорость и мультимодальность. И то и другое легко перепутать с прогрессом в том, что мне действительно нужно от модели в разработке. Поэтому зафиксирую тезис сразу, а дальше буду его разворачивать: быстрее — это не значит глубже, и для разработки важна не скорость токенов, а надёжность модели на твоём коде — и вот тут сдвиг минимальный.
Что в GPT-4o действительно новое, а что — упаковка
Начну честно: новое здесь есть, и оно реальное. GPT-4o — это не косметика. Модель быстрее и заметно дешевле предыдущей флагманской GPT-4 Turbo, у неё выше лимиты, она нативно принимает изображения и обещает голосовое взаимодействие с задержкой, близкой к человеческой. По заявленным бенчмаркам качество на тексте примерно на уровне GPT-4 Turbo, местами чуть лучше. То есть мы получили модель того же класса по «уму», но существенно дешевле и быстрее, плюс встроенную работу с другими модальностями.
И вот здесь важно не перепутать две разные вещи. Одно дело — характеристики раздачи: латентность, цена, лимиты, форматы ввода. Другое дело — рассуждательная способность на сложной технической задаче. Первое в GPT-4o выросло ощутимо. Второе — почти не сдвинулось относительно GPT-4 Turbo, если верить и заявленным цифрам, и тому, что я успел потрогать руками за неделю.
Это не упрёк. Удешевление и ускорение модели уровня GPT-4 — само по себе серьёзное событие для индустрии: то, что ещё недавно было дорогой роскошью на каждый запрос, становится дешёвым массовым инструментом. Но для меня как для инженера ключевой вопрос лежит в другой плоскости. Мне в работе почти никогда не мешала скорость ответа. Мне мешало то, что ответ бывает уверенно неправильным. А эту проблему скорость не лечит. Скорее наоборот.
Голосовой режим впечатляет, но мой код живёт в тексте
Демо голосового режима — самая яркая часть презентации. Модель можно перебить, она меняет интонацию, шутит, реагирует на эмоцию в голосе. Как продукт для широкой аудитории это, вероятно, действительно меняет ощущение от общения с ассистентом. Но давайте честно приземлим это до разработки.
Код — это текст. Очень структурированный, очень чувствительный к деталям текст, где значимы отступы, имена переменных, точные сигнатуры, версия библиотеки, конкретная строчка стека. Диктовать это голосом бессмысленно, а слушать сгенерированный код на слух — тем более. Разработка — это не разговор, это работа с точным артефактом, который нужно видеть, выделять, копировать, диффать и проверять глазами. Голос здесь не ускоряет, а добавляет лишний слой, через который теряется именно та точность, ради которой я и открываю модель.
Поэтому моя реакция на голосовой режим спокойная: это замечательная демонстрация и, возможно, отличный интерфейс для совсем других сценариев — обучения, ассистентов, доступности. Но это не про мой developer workflow. Здесь не работает фигура «теперь будем программировать голосом». Работает другая: не модальность ввода определяет ценность инструмента для инженера, а степень доверия к его выводу на твоей задаче.
Скриншот ошибки убирает трение на входе, но не добавляет глубины
А вот мультимодальность по картинке — это уже интереснее, и тут я готов признать настоящую пользу. Кинуть скриншот с ошибкой сборки, со странным состоянием в DevTools, с куском логов или с разметкой, которая «поехала», и сразу получить осмысленный комментарий — это экономит реальные минуты. Раньше я бы вручную перепечатывал текст ошибки или вырезал нужный фрагмент; теперь можно просто показать.
Но давайте посмотрим, что именно тут происходит. Польза от картинки максимальна там, где задача — распознать и перенести информацию: прочитать текст ошибки со скриншота, увидеть структуру таблицы, разобрать схему. Это сильная функция OCR и распознавания, упакованная в удобный интерфейс. И это действительно полезно. Но это помощь на этапе ввода данных, а не на этапе их понимания.
Потому что после того как модель «прочитала» скриншот, она дальше рассуждает ровно так же, как если бы я сам перепечатал текст ошибки. Картинка убрала трение на входе, но не добавила глубины анализа. И вот тут кроется тонкий момент: визуальный, мгновенный, уверенный ответ создаёт ощущение, что задача уже понята. Хотя на деле модель просто быстрее добралась до той же самой текстовой догадки — со всеми её прежними рисками ошибиться.
Почему для кода важна надёжность, а не скорость токенов
Если коротко описать, чем я реально занимаюсь с LLM в работе, то это не «спросил — получил». Это цикл: сформулировать задачу с контекстом, получить вариант, прочитать его критически, проверить против документации и реальной кодовой базы, отбросить неверное, оставить полезное. В этом цикле узкое место — не скорость генерации. Узкое место — это проверка. Именно она съедает время и внимание, и именно она определяет, выгоден ли инструмент в итоге.
Когда модель отвечает быстрее, цикл не сокращается там, где он действительно дорогой. Генерация и так занимала секунды. А проверка осталась ровно такой же по объёму работы: я всё так же должен убедиться, что предложенный API существует в нужной версии, что нет тихой подмены поведения, что edge cases учтены, что импорт не выдуман. На моём коде, с моими внутренними библиотеками и доменными правилами, модель по-прежнему ошибается примерно так же часто, как ошибалась GPT-4. Скорость это не меняет.
Более того, скорость может работать против меня. Когда ответ появляется почти мгновенно и выглядит уверенно, психологически проще проскочить этап проверки. Быстрый поток правильных по форме, но неточных по сути ответов — это не ускорение работы, это ускорение накопления тихих багов. Поэтому я сознательно не путаю две вещи: latency раздачи и cost of verification на моей стороне. Первое упало, второе осталось.
Чем глаже интерфейс, тем легче принять правдоподобный текст за решённую задачу
Здесь — самая важная для меня часть, где у удобства появляется счёт. У мультимодальности и скорости есть вполне конкретная цена, и она не в деньгах за токены. Цена в том, что низкое трение и высокая убедительность ответа подталкивают принять поверхностный разбор за разобранную задачу.
Механика простая и человеческая. Когда я печатал вопрос руками, я невольно формулировал задачу — а формулировка заставляет думать. Когда я просто кидаю скриншот, этот этап исчезает. Я делегировал не только ответ, но и саму постановку вопроса. А ответ приходит мгновенно, аккуратно оформленный, с интонацией уверенности. Всё в нём кричит «задача закрыта». И вот в этот момент очень легко закрыть вкладку, не пройдя проверку, потому что субъективно кажется, что разбор уже состоялся.
Но разбор задачи и получение правдоподобного текста — это разные события. Модель отдаёт второе, а я часто принимаю это за первое. Чем глаже и быстрее интерфейс, тем сильнее этот соблазн. Поэтому здесь снова та же фигура: дёшево получить ответ — не то же самое, что понять проблему, и удобство ввода повышает риск перепутать одно с другим. Это не аргумент против инструмента. Это напоминание о том, какую дисциплину он от меня требует.
Почему я всё ещё печатаю руками
Отсюда и заголовок. Я продолжаю набирать промпты текстом не из ретроградства и не потому, что не умею иначе. Я делаю это, потому что сам процесс печати — это часть моего мышления, а не досадное трение, которое надо убрать любой ценой. Несколько причин, почему я держусь за клавиатуру:
- Формулируя задачу словами, я вынужден её понять сам — и нередко нахожу ответ ещё до того, как нажму Enter. Это побочный, но ценный эффект письменной постановки.
- Текстовый промпт точен и воспроизводим. Я могу его сохранить, отредактировать, переиспользовать, показать коллеге. Голос и картинка таким свойством не обладают.
- Печатая, я задаю темп. Мгновенный голосовой обмен подталкивает к диалогу-болтовне, а текст оставляет паузу на критическое чтение ответа.
- Контекст под контролем. Я сам решаю, какой фрагмент кода, какую версию, какое ограничение положить в запрос. Скриншот часто несёт лишнее и теряет нужное.
Это не значит, что я игнорирую новые модальности. Скриншот ошибки я кидаю с удовольствием — там польза очевидна и риск низкий. Но ядро рабочего цикла остаётся текстовым и осознанным. Не потому что новое плохо, а потому что моя задача — не общаться с моделью быстрее, а принимать на её основе правильные инженерные решения.
Что GPT-4o реально меняет в моём рабочем дне
Чтобы не свалиться в скепсис ради скепсиса, перечислю, где сдвиг для меня настоящий. Дешевизна и скорость меняют экономику привычки. Когда запрос к сильной модели стоит дёшево и возвращается за секунду, я чаще задаю мелкие вопросы, которые раньше «не стоили» обращения: быстро уточнить синтаксис, накидать заготовку теста, объяснить незнакомый кусок чужого кода. Барьер на бытовое использование упал, и это ощутимо.
Распознавание скриншотов убирает рутинное перепечатывание. Это маленькое, но ежедневное удобство. Увеличенные лимиты и более длинный контекст позволяют закидывать больше кода за раз. Всё это — реальные, измеримые улучшения developer experience. Я их признаю и пользуюсь.
Но ни одно из этих улучшений не касается главного дефицита — надёжности на конкретной кодовой базе. Модель не стала заметно реже выдумывать API, путать версии или уверенно ошибаться в доменной логике. Поэтому моё отношение к её выводу не изменилось: всё, что идёт в продакшн-код, проходит ту же проверку, что и год назад. GPT-4o сделал обращение к модели дешевле и приятнее — но не избавил её ответы от необходимости проверки.
Демо оптимизируют под «вау» за минуту, инструмент — под полгода без подвохов
Полезно держать в голове разницу между демо и инструментом, потому что они оптимизируются под разное. Демо оптимизируется под первое впечатление: чтобы за минуту на сцене зритель сказал «вау». Скорость, голос, эмоция, мгновенный визуальный отклик — всё это идеальные ингредиенты для демо. Инструмент оптимизируется под другое: чтобы через полгода ежедневной работы он экономил время и не подводил в деталях.
Эти две оптимизации не противоречат друг другу, но и не совпадают. Часть того, что блестит в демо GPT-4o, в моём рабочем дне просто не находит применения — и это нормально, оно сделано не для меня. А часть, наоборот, незаметна на сцене, но ценна в работе: цена за токен, латентность на массовых мелких запросах, распознавание скриншота. Зрелое отношение к релизу — это умение отделить одно от другого и не покупать инструмент за качества его демо.
Именно поэтому я не разделяю ни восторга «теперь всё изменилось», ни обратной крайности «опять только маркетинг». GPT-4o — это не революция в способности модели понимать мой код. Это удешевление, ускорение и расширение интерфейса вокруг той же по сути способности. Сдвиг реальный, но он лежит в экономике и удобстве, а не в глубине разбора.
Что я беру из релиза, а что оставляю на сцене
GPT-4o честно дал то, что обещал: скорость, дешевизну, мультимодальность. Голос почти мгновенный, картинки читаются, ответы летят. Для широкого продукта это, возможно, шаг в новое качество взаимодействия. Но если смотреть из кресла инженера, который каждый день кладёт результат в реальную кодовую базу, то ключевая метрика — не латентность и не количество модальностей, а доля ответов, на которые можно опереться без долгой проверки. По этой метрике сдвиг минимальный.
Поэтому я продолжаю пользоваться моделью — больше, чем год назад, и спокойнее. Кидаю скриншоты, задаю мелкие вопросы, экономлю минуты на рутине. Но ядро работы остаётся прежним: формулирую руками, читаю критически, проверяю всё, что идёт дальше черновика. Скорость соблазняет проскочить эту проверку, и именно поэтому я сознательно её не отдаю.
Если сформулировать совсем прямо: GPT-4o сделал диалог с моделью быстрее и дешевле, но не сделал её вывод надёжнее на моём коде — а в разработке решает именно надёжность, не скорость, поэтому я всё ещё печатаю руками.