Разборки вайбкодеров: 40 тысяч строк, три мода за ночь и ни одного вопроса «н****а?» ДЛИННОПОСТ

Да, написала сетка. Нет, идеи мои. Да, сам перечитывал раза 2, редактировал, правил, форматировал и смотрел, чтобы было норм.

Последние пару лет слово «вайбкодинг» начали лепить вообще на всё подряд.

Написал функцию с ChatGPT? Вайбкодер. Попросил Claude найти ошибку? Вайбкодер. Не знаешь наизусть половину WinAPI, но используешь нейросеть как справочник? Всё, приехали, программист закончился, начался вайбкодер.

По-моему, это х***я.

Потому что между разработкой с AI и настоящим вайбкодингом сейчас уже не щель, а натуральная Марианская впадина.

Я сам делаю часть своих проектов с помощью нейросетей. Причём «часть» — это очень мягко сказано: непосредственно код зачастую пишет именно AI. Я не программист в классическом смысле, не сяду сейчас с чистого листа писать несколько тысяч строк Lua или C++.

Но вот что забавно: чем больше я смотрю на настоящий вайбкодинг, тем больше я понимаю, что то, что делаю я, и близко не вайбкодинг.

Потому что у меня получается AI-assisted development.

А у некоторых — уже скорее: AI development, human assisted.

Человек там нужен нейросети примерно для трёх вещей:

принести лог; запустить игру; нажать Upload.

Иногда даже README за него читать не требуется.

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

Откуда вообще появляется идея инструмента?

Допустим, я сделал один небольшой мод.

Потом второй.

Потом третий.

Каждый решает конкретную проблему/задачу. У каждого есть настройки. Где-то конфиг, где-то консольные команды, где-то ещё какая-нибудь техническая хрень, которая удобна автору и вообще не удобна обычному пользователю.

После нескольких недель работы возникает очевидная проблема:

Бл***ь, а почему пользователь вообще должен помнить пять команд и руками редактировать Lua-файл?

Вот здесь рождается идея общего меню настроек.

Не потому, что хочется сделать FRAMEWORK™.

Не потому, что хочется написать SDK.

Не потому, что «архитектура расширяемая».

Не потому, что идея «сделать моддинг инструмент, которым будут пользоваться все и так я налутаю скачек и, возможно, бабок».

А потому что существует конкретная проблема: настройки модов неудобны.

Сначала проблема. Потом несколько реальных примеров этой проблемы. Потом инструмент.

И дальше ты уже думаешь не «как сделать побольше», а наоборот:

как сделать так, чтобы другой автор подключил свой мод максимально просто?

Мне, например, было важно проверить не только «оно у меня работает».

Я буквально пытался повторить подключение собственного мода как человек, который ни х***я не программирует.

Открыл README. Взял пример. Сделал bridge по собственной же инструкции.

Посмотрел: можно ли реально понять, куда что вписать? Где можно ошибиться? Нужно ли человеку знать внутренности framework? Можно ли сделать Toggle или Number, не получив сначала диплом computer science?

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

Казалось бы, очевидная мысль. Но тут в комнату входит вайбкодер.

Он видит уже готовое решение и думает не: О, проблема решена. Делать нечего.

И не: Я вижу серьёзный недостаток, могу сделать лучше. Нет.

Он думает: О. Крутая штука. Сетка, е***шь мне такую же.

Вот этого вопроса в вайбкодинге практически не существует.

Нахера?

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

Так зачем ты вообще тратишь на это время и ресурсы дата-центров?

Я, например, если вижу, что какая-то задача уже нормально решена и мне нечего туда добавить, просто не полезу.

Потому что у меня есть миллион других вещей, которые ещё не решены. И я, блин, нормальный человек.

Можно сделать что-то полезное. Починить реальную проблему. Добавить функцию, которой людям не хватает.

А не заниматься разработческой версией «я тоже хочу свой TikTok».

Но у вайбкодера другая система мотивации. Ему не обязательно нужна проблема. Ему нужен продукт.

Ещё один. Свой. С собственной страницей. С собственным README. С красивой плашкой. С цифрой Downloads.

Зачем?

Хайп? Деньги? Donation Points? Цифра в профиле? Желание почувствовать себя великим разработчиком?

Хер его знает.

Но точно не потому, что мир остро нуждался в пятом способе нарисовать Toggle.

Самое прекрасное наступает, когда нейросеть просишь не просто решить задачу, а:

«Сделай мне профессиональный расширяемый framework».

Нейросеть обожает профессиональные расширяемые framework.

Будет SDK. Будет abstraction layer. Будет provider, adapter, host, runtime. registry, protocol, lifecycle, ещё один lifecycle для lifecycle.

Если очень повезёт, где-нибудь между ними даже останется кнопка On/Off, ради которой всё это начиналось.

В одном таком проекте простое окно настроек разрослось примерно до 18 тысяч строк Lua и нескольких десятков файлов.

В другом связанном проекте — уже за 20 тысяч строк.

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

Размер кода сам по себе, конечно, ничего не доказывает.

Иногда 50 тысяч строк абсолютно оправданы.

Но когда ты видишь:

десятки тысяч строк; десятки модулей; постоянные ticks и polling; rebuild'ы; debounce поверх rebuild'ов; retry logic поверх debounce; отдельную диагностику для диагностики; потом оптимизации того, что сам же framework начал тормозить;

становится трудно не задать один простой вопрос:

А может, надо было сначала не строить космодром?

Это вообще мой любимый жанр.

Сначала AI пишет огромную архитектуру. Потом выясняется, что какая-то операция занимает сотни миллисекунд.

Потом следующий промпт: Optimize performance.

И AI героически добавляет кэш. Потом выясняется, что кэш протухает.

Следующий промпт: Fix stale cache.

Добавляется invalidation. Потом invalidation вызывается слишком часто.

Добавляется debounce. Потом debounce ломает обновление.

Добавляется fallback.

Через 30 итераций README сообщает: Performance-focused architecture.

Ну ещё бы. Ты три дня только performance и чинил.

Я видел код, где прямо в комментариях, остались следы этого процесса. Не обычные комментарии вида:

-- Refresh map markers when area changes

А практически фрагменты разговора с coding assistant:

the user asked... her logs prove... I was wrong for four versions...

То есть нейросеть буквально продолжает беседу с пользователем внутри исходника. Человек даже не почистил это перед публикацией.

И вот тут уже термин «AI-assisted» начинает звучать немного смешно.

Кто кому ассистировал?

AI написал архитектуру. AI анализировал лог. AI объяснил, почему предыдущая гипотеза AI была неправильной. AI придумал следующий фикс.

Человек запустил игру и сказал: Не работает. После чего AI попробовал ещё раз.

Это не AI-assisted development.

Это уже не разработчик с AI-помощником. Это human assistant при AI-разработчике: принести лог, нажать кнопку, сказать «не работает». Мартышка у терминала, только мартышка, наверное, быстрее поняла бы схему эксперимента.

Ещё один прекрасный артефакт настоящего вайбкодинга — номера внутренних итераций.

Pass 41. Pass 87. Pass 132. Pass 183.

И первая публичная версия проекта внезапно: 0.71.8

Вот тут отдельно стоит остановиться. Нет ничего запрещённого в версии 0.71.8. Semantic Versioning полиция не приедет.

Но для первой публичной версии маленького мода это выглядит потрясающе.

Не 0.1. Не 0.7. Не 1.0. Даже не 0.71!

0.71.8.

Будто перед нами Chromium, который десять лет разрабатывали три международных офиса.

Что эта цифра вообще должна означать? 71 минорную версию? Восемь патчей 71-й версии? Где предыдущие 718 стадий эволюции?

Понятно, что версии можно нумеровать как угодно. Но когда первая публичная версия маленького мода — 0.71.8, а GitHub начинается одним финальным коммитом, выглядит это как внутренний номер итерации, который просто забыли привести в человеческий вид.

А GitHub при этом иногда состоит из одного коммита, куда человек просто выгрузил уже готовую пачку проектов.

То есть публичной истории разработки практически нет.

Зато внутри: Pass 183.

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

Нейросеть может сделать 183 прохода. Она может сделать 583. Это не означает, что архитектура стала хорошей.

Иногда это означает только то, что первые 182 раза она пыталась вылечить последствия того, что сама же придумала.

Дальше начинается уже фабрика.

Один мод. Через несколько часов второй. Потом framework. Потом UI Kit. Потом Cheat Menu. Потом ещё extension. Потом отдельная страница для extension к extension.

И всё это за день-полтора.

Технически возможно? Конечно. AI сегодня способен сгенерировать огромное количество работающего кода очень быстро. Но вот думать он за это время не научился.

И человек тоже почему-то не захотел.

Когда я делал несколько своих инструментов, они появлялись постепенно, за полмесяца — месяц. Потому что разработка даже с AI всё равно занимает кучу времени. А по ходу есть ещё личная жизнь.

Каждый инструмент решал какую-то задачу. Потом обнаружилась общая проблема. Потом появился общий инструмент. То есть архитектура выросла из использования.

У вайбкодера наоборот: архитектура появляется раньше необходимости.

Потому что architecture выглядит круто. SDK выглядит круто. Framework звучит солидно. А ещё можно сделать красивые README: Features, Installation, Compatibility, Troubleshooting, Known Issues, Third Party Notices, License, Changelog. Всё как у взрослых. Осталось только понять, зачем это кому-то нужно.

Вот здесь проходит ещё одна очень жирная граница.

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

Но если ты заявляешь: Это framework для других разработчиков! то появляется пользователь твоего API.

Другой моддер.

И внезапно возникает UX уже не для игрока, а для разработчика.

Нормальный вопрос: Сможет ли человек подключить свой мод, прочитав мою документацию?

Для простого settings framework идеальный сценарий выглядит примерно так:

Но можно сделать иначе.

Можно ради меню настроек предложить человеку: C++ host; собственный runtime; JSON schema; lifecycle extension; API; managed hooks; UI Kit; отдельный SDK.

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

НА-ХЕ-РА?

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

Он знает, что README существует. Потому что README написала нейросеть. Наверное, значит, всё понятно. Хотя, кому не похер.

Отдельный симптом — общение.

Человек задаёт простейший вопрос: Можно ли сделать закрытые области карты серыми?

Обычный ответ: Да, смотрю в эту сторону. Пока не обещаю, но выглядит реализуемо.

Два предложения.

Но AI так не может. AI должен помочь. Очень помочь. Он сейчас расскажет:

сколько часов велось исследование; как устроен save; почему у автора открыта только часть мира; какой widget отвечает за mask; какие эксперименты уже проведены; какие риски остаются; философию будущего дизайна fog of war; чем отличается minimap от world map; почему обещать результат пока рано.

Получается ответ размером с маленькую дипломную работу.

И вайбкодер просто берёт его и фигачит пользователю как есть.

Вот это, пожалуй, идеальная метафора всего процесса.

Человек даже не прочитал ответ достаточно внимательно, чтобы подумать: Бл***ь, ему же это нафиг не нужно.

Нет фильтра. Нет редактора. Нет понимания аудитории.

Есть: Generate → Copy → Paste.

И ровно так же: Generate → Build → Upload.

Самое смешное, что чел, который задал вопрос, пишет потом типа «круто, спасибо, мод крутой»))))

А теперь неприятная часть.

Большинство пользователей вообще этого не увидят. Им пофиг, сколько там строк. Им пофиг, что framework делает 17 лишних действий. Им пофиг, что внутри комментарии the user told me. Они не будут читать GitHub. Они не будут профилировать Lua.

Они увидят: О, миникарта! Скачают. Запустят.

Она вроде работает.

Напишут: BEST MOD ON NEXUS!!!

И всё.

Внешне хороший код и говнокод могут делать одну и ту же кнопку.

Разница становится заметной позже:

конфликтует; начинает лагать; ломается после обновления; съедает производительность; автор не понимает, что чинить без AI; любое изменение требует ещё двадцать промптов.

Но download уже засчитан. Endorsement уже поставлен. Страница уже поднялась.

И поэтому вайбкодинг сегодня прекрасно вознаграждается.

Особенно если ещё и не ставить AI-маркировку, чтобы пользователь случайно не задумался, откуда за сутки взялись четыре больших проекта.

Да.

Именно поэтому меня особенно бесит, когда всё это называют одним словом.

Инструмент не определяет качество работы.

Молотком можно собрать шкаф. Можно сломать шкаф. Можно ударить себя по пальцу.

Проблема не в молотке.

Есть старая история — кажется, скорее городская легенда, чем нормально подтверждённый случай — про человека, который постирал кошку в стиральной машине, а потом якобы судился, потому что в инструкции не было написано «не стирать домашних животных».

Правда это или байка — неважно.

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

Не поджигать изделие во время использования.

И сидишь такой: Кому, блин, это пришлось объяснить?

С AI сейчас то же самое.

Это чертовски мощный инструмент.

Он позволяет человеку без классического программистского образования делать вещи, которые ещё несколько лет назад были ему почти недоступны.

Но мощный инструмент требует хотя бы минимального понимания:

что ты делаешь? зачем? для кого? почему именно так?

Если этого нет, AI не превращает тебя в разработчика. Он просто позволяет тебе генерировать ошибки промышленными объёмами.

Раньше человек, который не умеет программировать, мог написать 40 строк плохого кода. Теперь он может за вечер написать 40 тысяч.

Прогресс.

Поэтому я бы вообще разделил два подхода.

AI-assisted development

Человек:

находит проблему; определяет цель; выбирает архитектуру; проверяет, нужна ли функция вообще; тестирует; отбрасывает плохие варианты; смотрит логи; заставляет AI упростить решение; проверяет документацию на реальном сценарии; несёт ответственность за результат.

AI:

пишет код; ищет варианты; помогает с reverse engineering; анализирует логи; ускоряет рутину.

И есть: Human-assisted AI development

— придумай архитектуру; — напиши код; — напиши README; — напиши changelog; — придумай название; — ответь пользователю; — исправь баг; — оптимизируй предыдущий фикс; — сделай ещё один framework.

Человек: Не пашет.

AI: Попробуйте эту версию.

Человек: Пашет.

AI: Great! Here's a polished Nexus description—

Человек: Copy.

Нет, сама идея «меню настроек для модов» не принадлежит одному человеку.

И «миникарта» тоже. И «общая библиотека» тоже.

Речь вообще не об авторском праве на Toggle. Речь о другом.

Есть очень мерзкий тип поведения:

увидеть чужую удачную работу, понять, что она получает внимание, и немедленно сделать такую же не потому, что ты можешь улучшить её, а потому что тоже хочешь кусок внимания.

Причём ты даже не пытаешься разобраться, почему оригинал сделан именно так.

Берёшь поверхность.

«У него settings framework?» Сетка, е***шь settings framework.

«У него карта с маркерами?» Е***шь карту.

«У него shared UI?» Shared UI тоже е***шь.

В итоге внешний список Features похож. А внутри — архитектурная свалка.

И это, пожалуй, главное отличие человека, который решает задачи, от человека, который производит контЕнт.

Первый иногда ничего не выпускает. Потому что не нашёл, что улучшить.

Второй обязан выпускать. Иначе цифра Downloads не растёт.

Для меня определение теперь примерно такое.

Вайбкодер — это не человек, который не умеет писать код без нейросети.

Это вообще неважно.

Вайбкодер — это человек, который делегировал нейросети не написание кода, а мышление о продукте и просто жмёт кнопки, как мартышка.

Он не спрашивает: Нужно ли это?

Он спрашивает: Можно ли это сгенерировать?

Не: Будет ли другому человеку проще?

А: Работает?

Не: Есть ли уже хорошее решение?

А: Можно сделать своё?

Не: Почему архитектура такая сложная?

А: Сетка сказала scalable.

И если завтра AI сможет за десять минут генерировать миллион строк вместо сорока тысяч, такой человек не станет делать проекты лучше.

Он просто начнёт генерировать больше говна быстрее.

Поэтому главный навык эпохи AI — возможно, вообще не умение писать промпты. А умение иногда посмотреть на красивый ответ нейросети и сказать:

Нет. Это х***я. Давай проще.

И ещё чаще:

Нахера мы вообще это делаем?

Потому что иногда лучший новый framework — тот, который ты не написал, поскольку нормальный уже существует.