Hacker News Digest

• Обсуждение сосредоточено на том, что PR объемом 9000 строк кода и 63 файла невозможно ревьюить и должен быть разбит на части или отвергнуться без разбора.
• Участники подчеркивают, что такие PR нарушают базовые практики разработки и требуют автора разбить PR на меньшие, самодостаточные части.
• Сообщество подчеркивает, что такие PR часто не сопровождаются тестами или документацией, что делает невозможным проверить их корректность.
• Некоторые участники отмечают, что такие PR могут быть результатом использования AI, что вызывает дополнительные вопросы о качестве и поддержке кода.
• В конечном счете, большинство участников соглашаются, что такие PR должны быть отвергнуты с просьбой к автору разбить их на меньшие части, если это возможно, или начать с RFC или документации.

Инструменты AI для кодирования создают новую проблему для open source-сообщества: они делают генерацию кода дешёвой, но не делают его ревью таким же. В результате мейнтернеры тратят непропорционально много времени на проверку кода, который был создан за секунды, но требует часов анализа. Автор предлагает бинарную систему: с одной стороны - прототипы, демонстрирующие идеи, с другой - PR, готовые к ревью.

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

• Обсуждение показало, что проблема не ограничивается кодом: LLM-генерированные PR, не раскрывая этого, создают нагрузку на рецензентов и нарушают принцип "не навредь".
• Сообщество разделилось: одни считают, что любой вклад полезен, другие настаивают, что важно различать, где использовался ИИ, и требуют прозрачности.
• Обсуждение затронуло вопрос, как отличить человеческий вклад от ИИ-генерированного, и какие нормы могли бы регулировать это.
• Участники обсудили, что если кто-то утверждает, что может писать код с LLM, то он должен быть способен писать и e2e тесты.
• Были выдвинуты идеи, что проекты могли бы требовать, чтобы вклад был помечен как ИИ-генерированный, и что в будущем репутация и идентичность могут стать критически важными для рассмотрения вклада.

Пользователь работает с несколькими моделями одновременно, каждая из которых выполняет атомарные коммиты. Основной стек — TypeScript и React, развернутый на Vercel.

Основная идея — использование инструмента codex (предположительно, внутренний инструмент или API) в качестве основного драйвера для разработки. Вместо того чтобы писать код вручную, пользователь использует несколько экземпляров codex (до 8 одновременно), каждый из которых работает над своей частью задачи. Каждый агент коммитит изменения самостоятельно, что позволяет поддерживать чистую историю.

Ключевые моменты:

• Контекст и координация. Несмотря на то, что агенты работают параллельно, пользователь тщательно управляет их работой, чтобы избегать конфликтов. Например, при работе над крупными изменениями он сначала запускает один агент для оценки, а затем уже основную группу.
• Инкрементальный подход. Вместо того чтобы пытаться решить все сразу, пользователь разбивает задачи на мелкие, атомарные шаги. Например, при обновлении зависимостей он не просто запускает скрипт, а сначала проверяет каждое изменение, затем тестирует, и только потом обновляет.
• Отказ от излишеств. Пользователь избегает сложных систем вроде прекоммит-хуков для валидации, так как они замедляют процесс. Вместо этого он полагается на то, что агенты достаточно умны, чтобы не допускать ошибок.
• Практичность. Инструменты выбираются по принципу "работает — не трогай". Например, codex используется вместо Claude Code, потому что последний стал слишком абстрактным (например, он может часами "думать" над простой задачей). codex же просто делает.

В целом, подход напоминает принцип "двигайся быстро и не ломай" (move fast and don't break things), но с уклоном в "двигаться быстро", даже если иногда что-то сломается. Это компенсируется скоростью: один агент может заменить целую команду, и даже если он ошибся, это быстро фиксится.

• Дискуссия разделилась на два лагеря: «AI пишет почти весь код» против «никакой AI не заменит разработчика»; при этом обе стороны сходятся в том, что важно уметь читать и ревьюить весь код, независимо от того, кто его написал.
• Участники обсуждали, что 300k строк кода, которые, как утверждается, были написаны ИИ, на самом деле могут быть просто увеличены в 10-15 раз по сравнению с тем, что написал бы человек, и что это вызывает сомнения в надёжности такого подхода.
• Поднимался вопрос о том, насколько можно доверять ИИ-написанному коду, и какие именно навыки требуются, чтобы эффективно использовать такие инструменты.
• Также обсуждалось, что важно ли вообще писать статьи о таких инструментах, если они не раскрывают, как именно они используются, и какие именно задачи они решают.

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

• Пользователи обсуждают, что код, сгенерированный LLM, часто выглядит правильным, но на практике требует переписывания, что перекладывает бремя на коллег-ревьюверов.
• Подчеркивается, что внедрение ИИ-инструментов часто сопровождается агрессивным продвижением, даже если это идет вразрез с продуктивностью и UX.
• Участники обсуждают, что вместо того, чтобы навязывать инструменты, компании должны инвестировать в обучение и поддержку разработчиков, чтобы они могли эффективно использовать ИИ.
• Поднимается вопрос, что если ИИ-инструменты действительно так эффективны, почему бы не сделать их использование добровольным, а не навязывать.
• Участники также обсуждают, что вместо того, чтобы требовать использование ИИ, компании должны сосредоточиться на создании культуры, где разработчики могли бы выбирать, какие инструменты использовать, включая ИИ, и где они могли бы расти.

Инженеры всё чаще запускают несколько агентов одновременно — например, одновременно работают несколько экземпляров Claude Code или Codex CLI в разных директориях или даже в разных репозиториях. Саймон Уиллисон, который сам пишет код на Python и JavaScript, решил проверить, насколько полезно это на практике.

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

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

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

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

• Обсуждение в основном вращается вокруг трёх тем: высокая стоимость ревью кода, параллельные агенты и их влияние на фокус и продуктивность, а также культурные и этические аспекты использования AI-агентов.
• Участники делятся личными стратегиями, такими как использование различных инструментов вроде Conductor и Crystal для управления агентами, и обсуждают, как сделать их более эффективными.
• Обсуждается, как сделать ревью кода менее трудоёмким, включая использование инструментов вроде bottleneck для ревью кода, и как влияет на продуктивность и фокус.
• Также обсуждается, как влияет на эффективность работы использование AI-агентов, и какие могут быть последствия для долгосрочной устойчивости и качества кода.

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

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

• Успешное применение набора AI-инструментов для поиска уязвимостей в проекте curl, что привело к множеству реальных исправлений
• Подчёркивается ценность AI не для генерации кода, а для анализа и указания на потенциально проблемные места, требующие внимания разработчика
• Обсуждение конкретных инструментов (ZeroPath, Claude Code, Cursor BugBot) и методик работы с LLM для эффективного поиска багов
• Отмечается проблема ложных срабатываний и спама от AI в прошлом, но в данном случае подход оказался эффективным
• Размышления о том, как интегрировать подобные AI-инструменты в рабочий процесс для аудита безопасности и повышения качества кода

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

Доступен в публичном превью для JavaScript и TypeScript экосистем. Агент анализирует код на предмет совместимости, выявляет устаревшие методы и даже предлагает модернизацию синтаксиса. Пользователи получают $15 ежемесячного кредита. Ключевое преимущество — сокращение рутины и предотвращение застоя обновлений в бэклоге за счёт автоматизации стратегических решений.

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

Разработчики всё чаще сталкиваются с увеличением времени на модификацию или исправление кода, сгенерированного большими языковыми моделями. Это явление, названное «долгом понимания», напоминает работу с унаследованными системами, где перед внесением изменений необходимо глубоко разобраться в логике и контексте кода. Однако масштаб проблемы стал беспрецедентным из-за лавинообразного роста объёмов нечитаемого кода, который ИИ-инструменты производят с огромной скоростью.

Команды, заботящиеся о качестве, тратят время на ревью и рефакторинг такого кода, сводя на нет первоначальную экономию времени. Другие же просто коммитят непроверенные и непонятые фрагменты, создавая риски на будущее. Хотя ИИ может помочь с 70% правок, остальные 30% приводят к «петлям безысходности», когда модели не справляются с задачей, и разработчикам приходится разбираться в чужом коде самостоятельно. Это накопление долга понимания становится бомбой замедленного действия для миллионов проектов.

• LLM-генерация кода ускоряет разработку, но часто приводит к сложному, плохо понятному коду, что создает долгосрочные проблемы с поддержкой и увеличивает "долг понимания".
• Мнения разделились: одни считают проблему поддержки LLM-кода преувеличенной или временной, другие видят в ней фундаментальный сдвиг, усугубляющий существующие проблемы с legacy-кодом.
• Предлагаются стратегии работы: строгий ревью, использование LLM только для тривиальных задач/черновиков, написание тестов и документации, либо полное принятие модели "черного ящика".
• Многие ожидают, что будущие LLM смогут сами понимать и поддерживать сгенерированный код, что изменит роль разработчика на более высокоуровневую.
• Параллель с прошлыми проблемами (офшорная разработка, копипаст с Stack Overflow), но масштаб и скорость генерации LLM создают беспрецедентные вызовы.

Код-ревью часто превращается в формальность из-за слишком больших и сложных пул-реквестов. Разработчики избегают глубокого анализа, ограничиваясь поверхностными комментариями, что ведёт к накоплению технического долга и уязвимостей. Ключевое решение — нормализовать возврат непонятных PR авторам и дробить функциональность на мелкие изменения объёмом до 300 строк, которые можно проверить за 5–10 минут.

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

• Критикуется подход к разделению PR по количеству строк кода, так как это может скрыть общую картину и усложнить понимание взаимосвязей между изменениями.
• Подчёркивается важность содержательных PR-ревью, а не формального одобрения, и необходимость вовлечения ревьюверов на ранних этапах разработки.
• Обсуждаются трудности создания "историй" через коммиты и необходимость баланса между скоростью разработки и качеством кода.
• Предлагаются альтернативы, такие как парное программирование и улучшение инструментов для инкрементального ревью, чтобы сделать процесс более эффективным.
• Отмечается, что успех ревью зависит от культуры команды, доверия и чётких ожиданий, а не только от технических аспектов.

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

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

• Важность написания читаемого кода с учетом целевой аудитории (уровня навыков читателей) и необходимости согласования стиля в команде.
• Критика восприятия функционального программирования (ФП) как исключительно сложного, с указанием, что проблема часто в неидиоматичном коде, излишне длинных цепочках методов или специфических особенностях языков (например, Haskell), а не в ФП как парадигме.
• Необходимость обучения, код-ревью и парного программирования для внедрения сложных концепций и выравнивания уровня команды, особенно при использовании нишевых языков (например, Scala).
• Споры о балансе между простотой (для младших разработчиков) и продвинутыми практиками, где чрезмерное упрощение может привести к посредственному коду, а сложность — к проблемам читаемости.
• Роль менеджмента в разрешении конфликтов через технические решения, которые могут ограничивать инструменты или стили (например, запрет ФП), иногда без глубокого понимания причин проблемы.

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

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

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

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

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

• Сомнения в эффективности использования ИИ для генерации кода из-за высокого процента ошибок и необходимости тщательного ревью, которое может быть более трудоемким, чем написание кода с нуля.
• Озабоченность качеством и надежностью ИИ-сгенерированного кода, особенно в зрелых проектах и open source, где отсутствие публичного ревью может подорвать доверие.
• Увеличение нагрузки на разработчиков из-за необходимости ревью большего объема кода, который часто требует повышенного внимания из-за непредсказуемости ИИ.
• Потеря преимуществ человеческого взаимодействия в процессе ревью, поскольку ИИ не может участвовать в обсуждении или доработке кода.
• Необходимость разработки новых процессов и инструментов для эффективного ревью ИИ-сгенерированного кода, включая возможность комментирования и взаимодействия с агентами.

Главное: «нет» — не вред, а забота.
Сохранять душу проекта важнее, чем расти функциями. Чёткая философия (зачем проект живёт) притягивает единомышленников и отпугивает «почти-полезное».

LLM-эра всё усложнила: код теперь дешёв, дискуссия исчезла. PR без issue — почти спам. FastMCP требует issue, но люди открывают односложные заглушки.

Как защищаться:

• Документируй «почему» в README.
• Перекладывай доказательную нагрузку на автора PR.
• Используй contrib/: полезный, но чуждый духу код живёт там без гарантий.

Личный вывод: раньше отвечал за 15 минут, теперь игнорю стену LLM-текста без MRE. Ручная работа и сообщество всё ещё делают проекты великими, а не «вайб-код».

• Мейнтейнеры устают от «приезжих» PR: люди присылают код, который не вписывается в философию проекта, не покрыт тестами или создан LLM-ом «на коленке».
• Популярный выход — чаще говорить «нет» и требовать предварительного issue; иначе проект превращается в вечный багажник чужих хотелок.
• Контрибьюторы возмущаются: «почему полезная фича отклонена?» Ответ: scope creep, лишняя сложность, поддержка ложится на одного человека, а время — конечный ресурс.
• Сторонники форков: хотите свою фичу — форкните, опубликуйте, сами и поддерживайте; мейнтейнер никому ничего не должен.
• LLM удешевили код, но не уменьшили расходы внимания мейнтейнера; дешёвые PR стали массовыми, обсуждение исчезает, поэтому «no» теперь дефолт.

Коротко:
Секреты в логах — это не «одним фиксом» решить нельзя. Ни 80/20, ни чудо-инструмента нет. Есть 10 «свинцовых пуль» — несовершенных, но при правильной раскладке работают.

---

Почему течёт

Причина	Пример
Прямой логинг	log.info(user) вместо log.info(user.id)
«Мусорные» дампы	logger.debug(req.headers)
Конфиги	debug=true выводит весь env
Зашитые секреты	JSON-поле password внутри структуры
Телеметрия	APM-сборщик хватает всё подряд
Пользователь	Вводит пароль в поле «имя»

---

10 «пуль»

1. Архитектура данных
   Разделяем «чувствительное» и «остальное» на уровне схемы; в логи идёт только последнее.

2. Трансформации
   Сериализуем через sanitize() или toLog() — явно выбрасываем секретные поля.

3. Domain-primitives

   • Компиляция: SecretString не реализует Display.
   • Рантайм: Redactable интерфейс, toString() → "***".

4. Read-once
   Пароль читается 1 раз, дальше объект пустой — логировать нечего.

5. Taint-tracking
   Помечаем вход как «грязный»; если доходит до логгера — exception. Дорого, но точно.

6. Форматтеры логов
   Пишем свой Layout / Encoder, который режет заранее заданные ключи рекурсивно.

7. Unit-тесты
   Проверяем assertThat(log).doesNotContain(secret); запускаем на каждый PR.

8. Сканеры
   Regex-правила + entropy-фильтры в CI и в production-потоке. Сэмплируем, чтобы не умереть от CPU.

9. Pre-processors
   Vector / Logstash / Cribl вырезают поля ещё до попадания в Elasticsearch.

10. Люди
    Code-review чек-лист: «есть ли тут .toString / JSON.stringify / printf без фильтров?».

---

Стратегия

1. Фундамент: классификация данных, единый словарь «что считать секретом».
2. Карта потока: от источника до хранилища логов.
3. Контрольные точки: валидация, sanitize, redact.
4. Защита в глубину: 2-3 слоя из списка выше.
5. План на инцидент: ротация, оповещение, forensics.

---

Итог:
Нет волшебства — только дисциплина и много мелких фиксов. Начните с 2-3 «пуль», которые дешёвле всего у вас, и двигайтесь дальше.

• Отличный пост: чёткий разбор проблемы «секреты в логах» и конкретные техники борьбы.
• Основные идеи: taint-tracking, in-band метки, GuardedString/SecureString, доменные примитивы new Secret(...).
• Сложности: стектрейсы, JSON, core-dumps, динамически создаваемые секреты, человеческий фактор.
• Защита в глубину: маскировать, ограничивать доступ к логам, не писать всё подряд, валидировать маски (Kingfisher).

Disciplined-AI-Software-Development
Методика структурирует совместную работу с ИИ над кодом:

• убирает раздутость,
• фиксирует архитектуру,
• сохраняет контекст.

Контрольные точки и жёсткие ограничения не дают проекту съехать в хаос.

• Пользователи спорят, стоит ли погружать Claude-Code в тонны контекста: одни делают «глубокий research-цикл» (Gemini/GPT-5 → план → агент), другие считают это медленнее ручного кода.
• Работает только жёсткий pipeline: план → ревью плана → промежуточный код-ревью → тесты/линтеры → финальное ревью; полный автомат без человека проваливается.
• LLM заставили разработчиков наконец писать документацию, но сами агенты плохо планируют и «заплывут» по мере роста кодовой базы.
• Эффективность высока лишь при маленьких, чётко заскоупленных задачах: 10-минутный спецификация → 3 часа генерации → 85 % покрытие тестами; большие коммиты всё ещё быстрее делать вручную.
• Главный риск: технология убирает бюрократию, но не переносит человеческую ответственность; ошибки агента = ошибка конкретного разработчика.

Погружён в технический долг
Книга-манифест о том, как разработчики и компании увязают в «техдолге» и выбираются из него.

• Что такое техдолг?
  Упрощения в коде, которые экономят время сейчас, но замедляют работу потом.

• Почему он растёт?
  Жёсткие дедлайны, отсутствие тестов, «потом поправим».

• Как измерить?
  Метрики времени на исправление багов, частота откатов, удовлетворённость команды.

• Как уменьшить?

  1. Выделять 20 % времени на рефакторинг.
  2. Писать тесты до кода (TDD).
  3. Проводить ревью каждого PR.
  4. Удалять мёртвый код.

• Культура
  Признайте проблему публично, отпразднуйте первый «день выплаты долга».

• Читатели спорят: кто-то хвалит тему и пользу книги, кто-то ругает «воду», анекдотичность и сомневается в ИИ-авторстве.
• Критикуют метафору «плавание против течения» и длинные главы; просят внятную структуру и кликабельное оглавление.
• Автор (loumf): 18 месяцев писал без ИИ, 4 раунда редакторов, половина текста за 1 $ – чтобы покупали только заинтересованные.
• Печать через месяц; Show HN подача съехала в обычную.
• Вывод: тема ценна, но подача и навигация пока спорны – автор собирает конструктив и правит.

Краткий перевод и сжатие

Инженер Sanity Винсент Куигли за 6 недель перешёл от ручного кода к 80 % генерации ИИ.
Ключевые идеи:

• 4 этапа: «пишу сам» → «ИИ как Stack Overflow» → «ИИ пишет, я ревью» → «я ставлю задачи, ИИ решает».
• 3 попытки:
  1. 95 % мусора, но быстрое черновое решение.
  2. 50 % мусора, структура ясна.
  3. Рабочий код после уточнений.
• Контекст: claude.md в корне проекта хранит архитектуру, стандарты, примеры.
• Команда агентов: один пишет код, другой тесты, третий документацию; ежедневно «забывают» контекст.
• Ревью: ИИ → я → команда; человек смотрит только критические места.
• Фоновые агенты: ночью чинят мелкие баги, утром присылают PR.
• Цена: 400 $/мес на токены, но экономит 30 % времени инженера (≈ 6 000 $).
• Риски: регрессии, безопасность, зависимость от ИИ.
• Эмоции: ушла «владение кодом», пришло «владение проблемой».
• Советы тимлиду: начинать с экспериментов, выделять «зоны ИИ», усиливать ревью.
• Советы разработчику: заведи claude.md, ставь ИИ задачи помельче, проверяй критикуй, не верь на слово.

• Участники сходятся: LLM хороши для отладки и брейншторма, но не способны самостоятельно писать сложный продакшен-код без доработки.
• Все обсуждают Claude Code: кто-то активно использует и хвалит, кто-то жалуется на переусложнённый код и высокие расходы (до $1500/мес).
• Повторяется один и тот же набор советов: дробить задачи, писать тесты, держать короткие циклы обратной связи, использовать линтеры и логирование.
• Некоторые инженеры предпочитают сначала строить архитектуру сами, а LLM оставляют для рутины; другие наоборот.
• Общий вывод: AI-ассистенты становятся стандартным инструментом, но пока не заменяют разработчиков и требуют постоянного контроля.

Краткий перевод и сжатие

• Тезис: руководители, заставляющие команды использовать ИИ, действуют опрометчиво и рискованно.
• Опрос: десятки разработчиков подтвердили, что их заставляют или «вдохновляют» применять ИИ на каждом этапе работы.
• Кейсы
  • В научной компании код ревью и даже собеседования проводят через общий аккаунт ChatGPT; джуны не могут отлаживать «улучшенный» ИИ код.
  • В агентстве «AI-first» сотрудникам буквально грозят увольнением, если не используют генераторы для брендинга, дизайна и кода.
• Итог: ответственность за качество и безопасность продукта нельзя перекладывать на инструмент, который часто ошибается.

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

Требование: раскрывать использование ИИ-инструментов при любом вкладе в проект.

• Что добавляется: в CONTRIBUTING.md новый раздел «AI-Generated Content Disclosure».
• Суть: авторы pull-request’ов и issue обязаны явно указывать, если текст, код, коммиты или дизайн были созданы или существенно изменены при помощи ИИ (ChatGPT, Copilot, Claude и т.д.).
• Формат: достаточно короткой пометки в описании PR/issue или в коммит-сообщении, например:
  AI-assist: code comments and variable naming via GitHub Copilot.
• Цель: сохранить прозрачность, облегчить ревью, защитить проект от лицензионных и качественных рисков.
• Без наказаний: нарушение не влечёт блокировку, но ревьюеры могут запросить уточнение.

• Проблема: LLM не может подписать DCO, а человек не может гарантировать происхождение кода, если он был сгенерирован ИИ.
• Правовые риски: код может быть заимствован из неизвестных источников, что создаёт угрозу нарушения авторских прав.
• Сообщество: многие мейнтейнеры требуют явного раскрытия использования ИИ, чтобы сохранить качество ревью и обучение новичков.
• Практика: проекты вроде Ghostty и Caddy уже маркируют AI-PR метками или текстовыми пометками.
• Противники считают, что важен результат, а не процесс, и предлагают полагаться на ревью кода, а не на дисклеймеры.

Код-ревью можно улучшить

Мы отложили эксперимент с git-review — инструментом, который делает ревью коммитом поверх PR.
Проблемы GitHub:

• состояние ревью не хранится в репозитории;
• всё через веб, с лагами и лишними кликами.

Локальный workflow
Я клонирую ветку, сбрасываю её, чтобы код выглядел «моим», и ревью в Magit: запускаю тесты, перехожу к определениям, помечаю файлы через git add -p.
Но оставлять замечания приходится в браузере: долго, неудобно, текстовое поле тормозит.

Идея git-review

• ревью = коммит с комментариями вида // CR(name): …;
• автор и ревьюер редактируют этот коммит (--force-with-lease);
• по окончании добавляется revert-коммит, сохраняя историю.

Почему не зашло
Комментарии в коде — супер, но:

• если меняешь код, комментарии смещаются и конфликтуют;
• --force-with-lease добавляет трения;
• нужен более мягкий merge для ревью, а не строгая цепочка хэшей.
  Довести до ума потребовало бы >500 строк «быстрого хака».

К тому же, в upstream-git может появиться Change-Id в стиле Gerrit, что изменит ландшафт.

• Основная боль: ревью приходит слишком поздно, заставляя переписывать всё с нуля.
• Решения: локальное ревью в IDE (IntelliJ, VS Code), stacked-PR, «reviewer merges»-подход.
• Инструменты: Gerrit, Phabricator, Graphite, GitButler, SourceHut, GitPatch, Tangled.
• Надёжный Change-ID в Git обещает фиксить проблемы с force-push и interdiff.
• Культура важнее инструментов: мелкие, самостоятельные коммиты, RFC-прототипы, совместное проектирование до кода.

• Поддержали идею RRT: не использовать LLM в критичных местах, ограничивать права и отслеживать вход/выход.
• Спорят, виноваты ли LLM в росте уязвимостей или это та же человеческая невнимательность, только ускоренная большим объёмом кода.
• Локальные модели и строгие code-review рассматриваются как частичное решение, но не панацея.
• Ключевой риск — давление «делай быстрее» приводит к меньшему тестированию и усталости ревьюеров.
• Сравнение с автопилотами: LLM-генерация кода может стать безопаснее среднего разработчика, но пока не лучше экспертов.

Почему наём — боль

Компании теряют время: 9 раундов, охота за «трендовыми» разрабами, не могут отличить программиста от LLM. Кандидаты страдают: лучшие разрабы (Rust, Haskell) проваливают стресс-интервью, рекрутеры называют их «не-технарями», а потом пропадают на месяцы.

Каким должен быть хороший процесс

1. Различать сеньора и маркетолога с ChatGPT.
2. Применимо к работе: код, архитектура, ревью, документация.
3. Долгосрочно: люди не взаимозаменяемы, уход дорого, специализация под стек выучивается за месяц.
4. Экономно: инженерное время дорого.
5. Уважительно: неуважение отпугивает лучших.
6. Вкус: быстрое, но грязное решение — долгий долг команде; «клей» (поддержка коллег) множит продуктивность.

Почему популярные форматы не работают

• Live-coding / LeetCode
  Не различают, не про работу, уничтожают уважение и вкус, дорогие при многократных раундах.

• Take-home
  Легко сгенерировать ChatGPT, неуважительны к времени кандидата, отпугивают сильных.

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

• Современные «интервью» больше похожи на серию экзаменов, чем на профессиональный разговор.
• Многие считают, что достаточно 1-2 коротких встреч или пробы через контракт «temp-to-perm», чтобы понять, подходит ли человек.
• Популярные live-coding и leetcode почти не отражают реальную работу и отбирают не тех специалистов.
• Лучше обсуждать реальные задачи, ревьюить существующий код или решать мелкий баг в паре — это ближе к ежедневным обязанностям.
• Кандидаты теряют время и энергию на домашние задания и 9-часовые циклы, поэтому всё чаще «интервьюируют» и сами компании.

• Чёткое ТЗ — пишу заранее, чтобы агент видел контекст.
• Файл-инструкция по запуску линтервов и сборки.
• Саморевью — прошу Claude проверить свой код.
• Глобальный гайд ~/.claude/CLAUDE.md с правилами: мелкие шаги, TDD, простые решения, максимум 3 попытки при ошибке.

Качество
Я вручную читаю и тестирую всё, что выходит из LLM; отвечаю за PR независимо от автора кода.

• Ключ к успеху — писать подробные спецификации: кто-то тратит 2 часа на 12-шаговый документ и получает отличный результат, другие же считают, что даже «чистые» спеки не спасают от схода с курса и бесконечных правок.
• Мнения о CLAUDE.md разделились: одни держат файл коротким (<100 строк) и минималистичным, другие вообще не видят в нём пользы из-за «context rot» и субъективных инструкций.
• Работа с большими старыми кодовыми базами по-прежнему сложна: большинство признаёт, что Claude Code лучше справляется с новыми pet-project’ами, чем с «грязными» legacy-фичами.
• Популярные тактики: шаг-за-шагом микро-PR, TDD-агент, запуск puppeteer-тестов для «замыкания цикла», code-review собственных патчей самим агентом.
• Некоторые вообще отказались от спецификаций: инкрементально подсказывают «следующий шаг, какой сделал бы я», сразу коммитят дифф и правят на лету.