Hacker News Digest

Идея‑артефакт стал почти мгновенной: описав нужное, вы получаете рабочий вариант быстрее, чем писать первый кусок кода вручную. Раньше «стена» — длительные отладки, API‑подводные камни и недельные часы отладки — отделяла тех, кто мог, от тех, кто только говорил. Теперь эта стена арендована, и единственное, что осталось, — ваш вердикт.

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

Тред смещает фокус с абстрактного «вкуса» на дисциплину, архитектуру и социальный контекст. Участники утверждают, что без опыта отладки и понимания систем «вкус» невозможен; текущая эйфория по AI-генерации кода игнорирует проблемы поддержки, качества документации и реальных бизнес-задач. @madrox и @purplemoonx оспаривают ценность «вкуса»: если конкуренты копируют UX и фичи за дни, он не даёт преимущества. @purplemoonx сравнивает это с дизайном 2010-х — Figma автоматизировала рутину, сделав «сырой навык» ненужным. @KurSix, @jopsen и @agentultra подчёркивают: генерация черновика стала дешёвой, но отладка в проде, поддержка через полгода и оценка абстракций — дороги. «Стена» трения была учебной программой для вкуса; её исчезновение ставит под вопрос подготовку новых инженеров (@nunez). @luckystarr и @gregwebs предлагают формализовать вкус через «guardrails» и правила: накопленный опыт ошибок сужает пути LLM к связной системе. Вкус экономит время на баги, но требует умения направлять LLM, а не подчиняться ему. @boron1006 и @GrayHerring критикуют качество AI-продуктов: код часто беден сигналом (500 слов на модуль), большинство «свежих» продуктов посредственны и не решают реальных задач. @burnto добавляет: вкус часто определяется классом и ресурсами, а не только навыком. @abrbhat и @stiiv разделяют ремесло и инженерию: в инженерии важны теория, системы и дисциплина, а не интуиция. Отсутствие дисциплины в командах, полагавшихся на вкус как прокси, приводит к накоплению «slop» — это ускоряется с LLM. @the_wolo и @cccchara указывают: фокус на вкусе отвлекает от социального контекста. AI переносит акцент на социотехнические системы — важны социальные навыки и понимание «зачем», а не только эстетика. @jdzikowski отмечает сдвиг дефицита: раньше — дефицит создания, теперь — дефицит принятия. Продукты без вкуса менее жизнеспособны: создание дешево, внимание пользователей — ограничено.

В предоставленном тексте отсутствует основное содержимое репозитория GitHub "jackdoe/pico2-swd-riscv", представлено только навигационное меню сайта. Судя по названию проекта, вероятно, это реализация интерфейса отладки SWD (Serial Wire Debug) для платформы на базе RISC-V, возможно, связанная с Raspberry Pi Pico 2. Однако без доступа к файлам проекта, README или описанию невозможно дать точное резюме.

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

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

В работе с monorepo, где ежедневно делаются сотни коммитов, тесты внезапно начали проваливаться. Проблема была в изменении конфигурационного файла, который ссылался на неверный аккаунт, но найти виновника среди множества коммитов вручную было невозможно. Тогда коллега применил git bisect - инструмент, использующий бинарный поиск для локализации проблемного коммита. Это позволило точно определить, где именно был внесен сбойный код, после чего откат этого коммита восстановил работоспособность системы.

В статье приведен наглядный пример репозитория с функцией сложения, где намеренно введена ошибка - преобразование аргументов в строки. Запуск git bisect start, указание "плохого" и "хорошего" коммитов, затем git bisect run ./test_script.sh автоматически проверяет промежуточные версии. Инструмент последовательно тестирует коммиты, сокращая количество проверок вдвое на каждом шаге, и точно находит первый сбойный коммит, где функция add начала возвращать строку вместо числа.

• git bisect is a powerful tool for pinpointing the exact commit that introduced a bug, especially in large or poorly tested codebases.
• Its real value is in narrowing the search space when you lack the tests or architecture to reason about the code, not in replacing proper testing or code review.
• The discussion exposed a cultural divide: some developers see bisect as a last-ditch rescue tool for when tests or architecture have already failed, while others argue that if you need it, your process has already failed.
• Several commenters pointed out that if you have to reach for bisect, you probably lack tests, logging, or a clear commit history, and the real fix is to improve those, not to rely on bisection.
• The thread also surfaced the point that bisection is only useful if you can reliably detect the bug in every commit; if the bug is non-deterministic or only shows up in production, the tool becomes much less useful.

Автор написал новую реализацию ML-DSA — постквантового алгоритма подписи NIST на Go, но столкнулся с проблемой: функция Verify постоянно отвергала действительные подписи. Уставший после четырех дней работы, он решил попробовать Claude Code для отладки. ИИ мгновенно обнаружил сложную ошибку: при верификации высокие биты w1 брались дважды из-за неправильного повторного использования функции, объединяющей HighBits и w1Encode. Claude Code загрузил код в контекст и сразу нашел проблему без предварительных исследований, затем написал тест для подтверждения гипотезы.

Второй эксперимент с синтетическими ошибками подтвердил эффективность Claude Code: он нашел ошибку в вычислении констант в Монтгомери и проблему с длиной значения в подписи (32 бита вместо 32 байт), потратив меньше времени, чем автор. Хотя Claude Code иногда сдавался после частичного исправления, его способность быстро находить сложные ошибки в низкоуровневой криптографии впечатлила. Автор признал, что до сих пор не понимает, когда лучше использовать ИИ-инструменты, но этот опыт стал отличным кейсом для скептиков.

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

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

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

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

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

• Apple, Google и другие гиганты не смогли превратить LLM в полезные ежедневные функции, а лишь предложили эмодзи-генераторы и сводки уведомлений, что подтверждает: даже у них не получается сделать AI полезным.
• Основная причина — нет надёжного способа «починить» LLM, потому что они не детерминированы и не поддаются традиционному дебагу; это делает невозможным предсказать или гарантировать поведение.
• Соответственно, любые заявления о «безопасности» или «контроле» AI в основном маркетинговый фолсификат; никто не может гарантировать, что модель не выдаст опасный вывод при следующем промпте.
• Парадокс в том, что хотя LLM могут помочь писать код, они всё ещё не могут его самостоятельно тестировать; так что безопасность и надёжность остаётся на совести разработчика, который не может быть уверен, что модель не будет вредоносной.
• И наконец, никто не знает, как заставить модель вести себя так, как хочет пользователь, и нет способа «починить» её, если она ведёт себя не так, как ожидается.

Vibe-кодинг глазами ветерана

Эксперимент
2 недели, 40 часов, 5 k строк Python: AI-агент и я пишем микро-игру с алгоритмами A*, Minimax и пр. Цель — проверить, вытесняет ли LLM «искусство программирования».

Процесс

• Промптинг: описываю задачи естественным языком, AI генерирует код.
• Рефакторинг: «сделай класс короче», «добавь тесты» — срабатывает 80 %.
• Отладка: трассировка стека + «почему падает?» — LLM быстро находит баги.
• Архитектура: за меня выбирает структуру пакетов, но я корректирую.

Что понравилось

• Скорость: MVP за 3 вечера.
• Меньше рутины: никаких «import os.path.join».
• Новые идеи: AI предложил кэш-стратегию, которой я не планировал.

Что не так

• «Галлюцинации» API: методы, которых нет в библиотеке.
• Сложные баги: race condition LLM не видит без контекста.
• Читаемость: имена вроде helper_utility_v2 приходится переименовывать.

Выводы

• Junior-девелопер теперь = «человек, который умеет спрашивать».
• Сеньор нужен, чтобы фильтровать, тестировать и нести ответственность.
• Синтаксис умирает, зато растёт ценность системного мышления и prompt-инженерии.

Советы ветеранам

1. Делайте микро-промпты: «добавь docstring» → «добавь пример вызова».
2. Держи CI/CD: автотесты ловят ошибки, которые AI пропустил.
3. Используй AI как пару, а не замену: «покажи diff» вместо «перепиши всё».

Итог
Vibe-кодинг не убивает профессию, а сдвигает фокус: от написания символов к управлению смыслом. Сборочная линия есть, но над ней всё ещё нужен человек с вкусом.

• Участники сравнивают LLM с консалтинговой фирмой: 50 % шанс получить эксперта, 50 % — стажёра; приходится перечитывать каждую строку.
• «Vibe-coding» (генерация без чтения) вызывает опасения: сложно дебажить, нельзя защитить авторские права, а тонкие баги пролезают.
• Опыт показывает: AI полезен в известных языках и задачах (Python, CRUD), но почти бесполезен в нишевых (C/C++ gamedev, Prolog, Haskell).
• Старшие разработчики всё равно нужны: только они могут проверять, направлять и «владеть» кодом, созданным ИИ.
• Возникает вопрос: если не брать джунов, откуда возьмутся будущие сеньоры?
• Предлагают термины вместо «vibe-coding»: «pro-coding», «prompt-coding», «reviewing code».

Почему LLM не могут строить ПО

Эффективный инженер постоянно прокручивает цикл:

1. формирует ментальную модель требований,
2. пишет код,
3. проверяет, что он реально делает,
4. сверяет модели и правит код или требования.

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

Даже если модели станут мощнее, им нужно научиться так же «держать в памяти» и переключаться между уровнями детализации. Сейчас они страдают от выпадения контекста, пристрастия к свежим фактам и галлюцинаций. Работа над «памятью» идёт, но пока LLM не понимают происходящего и не могут сравнивать две похожие модели, чтобы решить, что менять.

LLM полезны: быстро генерируют код и документацию, справляются с простыми задачами. В сложных случаях человек всё равно должен контролировать требования и проверять результат. В Zed верят в совместную работу человека и агента, но руль остаётся за инженером, а LLM — лишь инструмент.

• LLM хороши как инструменты-ассистенты: быстро пишут boilerplate, находят мелкие ошибки, экономят время на рутине.
• Главный недостаток — неспособность удерживать и «поддерживать» целостную ментальную модель задачи; контекст «размывается» или меняется непредсказуемо.
• Поэтому при росте кодовой базы отладка превращается в «чтение спагетти», и инженер всё равно вынужден начинать заново.
• Решение — не «больше контекста», а системы-обёртки: TDD-циклы, пошаговое планирование, документация-модель, строгие промпты.
• Вывод: сейчас LLM заменяют джунов и Google-поиск, но полноценное ПО без человека, который держит «теорию» проекта в голове, построить не могут.