От рукописного кода к ИИ-управляемому ПО: DHH переписал Python-библиотеку с помощью Claude

Введение

Год назад создатель Rails Дэвид Хайнемайер Ханссон (DHH) был одним из известных разработчиков, отстаивавших удовольствие от рукописного кода.

Сегодня его позиция кардинально изменилась.

Проведя больше времени с Claude Code и Codex, DHH недавно использовал Claude Fable 5 для переписывания Python-библиотеки TerminalTextEffects на Rust. Согласно статье-источнику, проект потребовал около 11 миллионов токенов и был выполнен преимущественно в режиме автономной работы агентов.

Результат впечатляет: время запуска, по сообщениям, снизилось с 87 миллисекунд до 2 миллисекунд, а скорость рендеринга выросла примерно в 9,6 раза.

Этот эксперимент также поднимает более масштабный вопрос. Если опытный программист может передать крупномасштабную задачу переписывания ИИ-агентам и получить рабочий результат почти без прямого вмешательства, то что же программистам придётся делать через пять лет?

Передать клавиатуру ИИ и уйти на пенсию?

Контраст между позицией DHH и его взглядами год назад очевиден.

В мае 2025 года он опубликовал статью «Программирование должно быть чувством!», утверждая, что ИИ должен быть ближе к парному программисту: подходить для просмотра API, ответов на вопросы, помощи в решении конкретных проблем, но не заменять сам акт написания кода.

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

В шестичасовом разговоре с Лексом Фридманом DHH также описал ощущение потери «мышечной памяти», когда ИИ многократно генерировал за него код.

Один из примеров касался сборки дистрибутива Linux. Он заставлял ИИ многократно генерировать одно и то же Bash-условие, но обнаружил, что, поскольку он сам не писал это условие вручную, внутренне не чувствовал, что по-настоящему его усвоил.

Это подвело его к более глубокому вопросу: ослабляет ли ИИ-ассистируемое программирование то, как разработчики изучают разработку ПО?

Но, согласно статье-источнику, к апрелю 2026 года его позиция сместилась к агентно-ориентированному рабочему процессу.

Сегодня он открыто обсуждает: как будет выглядеть разработка ПО, когда клавиатура перестанет быть основным интерфейсом взаимодействия?

Claude Fable 5 разбирает Python-библиотеку и пересобирает её на Rust

Выбранный DHH проект — TerminalTextEffects (TTE), движок визуальных эффектов для терминала, который можно использовать как в качестве CLI-приложения, так и в качестве Python-библиотеки.

TTE предоставляет движение текста, цвета, градиенты, анимации и другие визуальные эффекты для терминала. Его публичный репозиторий описывает его как движок визуальных эффектов для терминала и документирует использование как через CLI, так и через Python-библиотеку.

В статье-источнике говорится, что DHH попросил Claude переписать этот проект на Rust.

Получившийся Rust-проект называется ttfx и размещён в организации DHH Omarchy. Согласно статье, новая версия поддерживает 37 эффектов и упакована в исполняемый файл размером около 3 МБ, не требующий Python-рантайма.

По сообщениям, выполнение заняло около 3 часов 11 минут.

Rust-реализация содержит около 21 000 строк основного кода, что близко к объёму исходной Python-версии.

Кодовая база.

Рабочий процесс также радикально отличается от традиционного «ИИ-автодополнения».

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

В этом смысле описание «выполнено с одного раза» не означает, что ИИ выдал всё одним поколением. Это означает, что DHH передал задачу, позволив агентам самостоятельно вести цикл разработки.

Codex получил ту же задачу

DHH повторил эксперимент с Codex.

Согласно статье-источнику, одного промпта оказалось достаточно для ещё одного сильного результата. Однако, по сообщениям, версия Codex заняла примерно на 30% больше времени и стоила около 43 долларов США, что примерно эквивалентно 290 юаням.

Это сравнение ценно, поскольку оно уводит внимание от упрощённого представления «ИИ-программирование либо волшебно, либо ужасно».

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

Команда Anthropic также заметила этот эксперимент.

По сообщениям, создатель Claude Code Борис Черный публично отреагировал на результат, а исследователь Anthropic Тарик спросил DHH, сколько планирования или проектирования рабочего процесса он вложил в переписывание.

Ответ DHH, пожалуй, самая удивительная часть.

Он сказал, что в основном позволил Claude составить план, а затем просто отпустил ситуацию.

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

Этот подход был осознанным невмешательством.

Выполнение с одного раза не означает вслепую

Здесь есть важное различие.

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

В статье-источнике говорится, что DHH сначала попросил Claude составить план, а затем позволил агентам самостоятельно выполнять, тестировать и итерировать.

Это ближе к делегированию программно-инженерного проекта, чем к требованию от системы автодополнения сгенерировать следующие десять строк кода.

Этот агентский стиль разработки в значительной степени опирается на:

• Кодовую базу с понятной структурой.
• Надёжный набор автоматизированных тестов.
• Чёткие команды сборки и запуска.
• Возможность создавать ветки и объединять изменения.
• Агентов, способных проверять сбои и повторять попытки.

Без этой основы автоматизация «с одного раза» становится гораздо менее надёжной.

Более масштабная демонстрация: миграция миллиона строк в Bun

TerminalTextEffects — всё ещё относительно небольшой проект.

Поэтому статья-источник указывает на более крупный пример: Bun, JavaScript-рантайм, созданный Джарредом Самнером.

Bun исторически строился вокруг Zig. В 2026 году его кодовая база подверглась значительной миграции на Rust с широким использованием ИИ-агентов кодирования.

В статье-источнике эта работа описывается как миграция примерно миллиона строк, выполненная менее чем за две недели.

Более поздние публичные записи подтверждают, что Rust-переписывание Bun было объединено в основной репозиторий. Pull request о переписывании на GitHub был объединён 14 мая 2026 года, и эта миграция заменила прежний путь сборки на основе Zig архитектурой, ориентированной на Rust.

Миграция более детальна, чем простое «ИИ переписал Bun».

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

Это значимое различие.

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

Предельные издержки кода стремятся к нулю

Статья-источник делает из этих примеров более масштабный вывод.

По мере роста возможностей агентов кодирования предельные издержки генерации очередной реализации продолжают снижаться.

Генерация кода становится всё дешевле.

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

Это меняет структуру затрат на разработку ПО.

Вопрос больше не просто:

Сколько разработчиков мы можем нанять для написания этого кода?

Он всё чаще становится:

Сколько полезных задач по разработке ПО один разработчик может делегировать группе ИИ-агентов?

Это и есть переход от ИИ-ассистируемого программирования к ИИ-управляемой разработке ПО.

Программисты следующего поколения могут стать больше похожи на укротителей драконов

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

Статья-источник считает этот вывод слишком упрощённым.

«Никто не пишет код вручную» не означает «нет программистов».

Содержание работы может измениться.

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

1. Определение того, что нужно построить.
2. Установление ограничений и интерфейсов.
3. Проектирование систем тестирования.
4. Анализ архитектуры и компромиссов.
5. Проверку того, что сгенерированный ИИ код действительно корректен.
6. Решение, что следует автоматизировать, а что нет.

В этой модели дефицитным навыком становится не набор синтаксиса.

Это знание того, что стоит создавать и что на самом деле означает правильное поведение.

Что становится ценным, когда код пишет ИИ?

Если реализация становится всё дешевле, другие навыки становятся более ценными.

Продуктовое суждение

Кто-то по-прежнему должен решать, какие проблемы стоит решать. ИИ

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

Системный дизайн

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

Тестирование

Чем больше кода может генерировать ИИ, тем важнее становится автоматизированное тестирование.

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

Техническое направление

Кто-то должен сообщать агенту, какие ограничения соблюдать.

Сюда входят бюджеты производительности, требования совместимости, границы безопасности, зависимости и цели долгосрочного сопровождения.

Другими словами, роль человека смещается на более высокий уровень абстракции.

В будущем речь может идти меньше о кодировании и больше

о направлении

Примеры из исходной статьи указывают на другое определение программирования.

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

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

Вот почему опытные инженеры, вероятно, сохранят ценность, даже если ручное кодирование станет менее центральным.

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

Часто задаваемые вопросы

Действительно ли DHH переписал библиотеку Python с помощью ИИ?

Да, согласно исходной статье. Основатель Rails Дэвид Хайнемайер Ханссон использовал Claude Fable 5 через высокоавтономный мультиагентный рабочий процесс, чтобы переписать TerminalTextEffects с Python на Rust.

Что такое TerminalTextEffects?

TerminalTextEffects (сокращённо TTE) — это движок визуальных эффектов для терминала, также доступный как библиотека Python. В его публичной документации описаны эффекты для движения текста, цветов, градиентов, анимации и другой визуальной обработки терминала.

Чем переписывание на Rust отличается от обычного ИИ-кодирования?

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

Codex тоже выполнил переписывание?

Согласно исходной статье, DHH поставил Codex ту же широкую задачу, и также получил отличный результат. Сообщается, что это заняло примерно на 30% больше времени и стоило около 43 долларов.

Bun тоже был переписан с помощью ИИ-агентов?

Да. Масштабное переписывание Bun с Zig на Rust было выполнено при значительной поддержке ИИ-агентов, и приоритизированный на Rust код был объединён в основной репозиторий в мае 2026 года.

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

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

Какие навыки наиболее важны в рабочих процессах ИИ-кодирования?

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

Связанные инструменты

• Claude Code: агентная среда кодирования от Anthropic для разработки программного обеспечения на уровне репозитория.
• OpenAI Codex: агент кодирования от OpenAI для многошаговых задач разработки программного обеспечения.
• TerminalTextEffects: проект терминальных эффектов на Python, обсуждаемый в исходной статье.
• Bun: среда выполнения JavaScript, завершившая крупное переписывание с Zig на Rust в 2026 году.
• Rust: системный язык программирования, использованный для переписывания TTE и реализации Bun.

Связанные ссылки

• Репозиторий TerminalTextEffects на GitHub: официальный репозиторий исходного кода TTE.
• Документация TerminalTextEffects: документация по использованию и разработке проекта.
• Репозиторий Bun на GitHub: официальный репозиторий исходного кода Bun.
• Pull request переписывания Bun на Rust: объединённый pull request миграции с Zig на Rust.
• Официальный сайт Rust: официальная документация языка Rust и ресурсы экосистемы.
• Claude Code: официальная информация об агентe программирования от Anthropic.

Резюме

Эксперимент DHH с TerminalTextEffects — полезный пример того, как ИИ-агенты программирования могут изменить единицу работы над программным обеспечением. Вместо того чтобы просить ИИ писать по одной функции за раз, разработчики всё чаще делегируют целые задачи рефакторинга и миграции командам агентов.

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

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