AI-коды на 24 часа. Будущее здесь (и оно несовершенно).

Коул Медин хотел узнать, что происходит, когда перестаешь рассматривать ИИ как автозаполнение кода и начинаешь относиться к нему как к младшему инженеру, который никогда не спит. Поэтому он запустил новую «долгосрочную агентскую систему» Claude Code от Anthropic и заставил ИИ работать круглые сутки, без перерывов и кнопки «Я закончил». Результат: стресс-тест не на основе сырого интеллекта модели, а на предмет того, могут ли агентные системы успешно завершить реальный программный проект от начала и до конца.

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

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

Открытый кодовый интерфейс Anthropic, который Медин взял из GitHub, объединяет все это. Агент «инициализатор» задает характеристики, задачи и тестовые наборы, затем специализированный кодировщик многократно редактирует файлы, запускает тесты и проверяет ошибки. Каждая сессия ведет себя как мини-спринт, а интерфейс связывает десятки таких спринтов один за другим.

На протяжении примерно 24 часов система провела более 50 сеансов кодирования, охватывая бэкенд API, фронтенд компоненты и тестовые фикстуры. Тесты в браузере выступали в роли беспощадного судьи: они либо подтверждали, что функция работает, либо отправляли агента обратно в редактор. Прогресс происходил скачкообразно, когда ИИ исправлял неудачный поток, а затем сталкивался с новым краевым случаем интеграции.

К концу немного больше половины всех тестов прошло, что было достаточно для создания узнаваемого интерфейса в стиле claude.ai, но далеко от идеального клона. Испытание показало, что "24 часа ИИ" не равняются волшебным образом "готовому к запуску SaaS", но одновременно это также доказало, что современные агенты могут справляться с нетривиальной, многоуровневой программной работой, когда им предоставляют структуру, настойчивость и четкие метрики завершения.

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

В своей сути, система находит на круге: план → код → тест → доработка. Клода предлагает изменения, редактирует файлы, запускает автоматические тесты или сервер разработки, проверяет результаты, а затем принимает решение о следующих действиях. Этот цикл повторяется десятки раз, именно на это полагается Коул Медин, когда он просит Клода следить за клоном claude.ai в течение 24 часов подряд.

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

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

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

Поскольку система сохраняет состояние на диск и возвращает его в подсказки, Claude может рассуждать о вчерашних миграциях или об одном ненадежном UI-тесте, который постоянно дает сбои. 24-часовой запуск Medin показывает результат: система не просто генерирует код, она orchestrates ongoing negotiation между планом и реальностью, измеряемую в прошедших тестах, а не в красивых демонстрациях.

Ваши тесты, а не ваши команды, действительно стали основой этого 24-часового эксперимента. Коул Медин рассматривал разработку через тестирование (TDD) как рулевое управление: определите, что означает «сделано» в коде, а затем позвольте Claude Code работать, пока реальность не соответствует спецификации. Никаких ощущений, никаких «выглядит хорошо для меня», только красный или зеленый.

Прежде чем агент написал хоть строку пользовательского интерфейса, Коул создал полный набор тестов, который охватывал основные сценарии claude.ai. Тестовая система учитывала создание беседы, историю сообщений и артефакты как четкие требования, а не абстрактные цели. Успех означал, что тесты пройдены, или агент продолжал работу.

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

Прогресс перестал быть субъективным практически сразу. После каждой сессии кодирования механизм запускал тесты и выводил простую таблицу результатов: X из Y прошли, плюс трассировки стека для неудач. За примерно 50+ сессий в течение 24 часов это число медленно увеличивалось с нуля до "немного более половины" успешно пройденных тестов.

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

Коул сильно полагался на тесты от начала до конца, которые имитировали реального пользователя в безголовом браузере. Используя инструменты, такие как Playwright или Puppeteer, тестовый стенд выполнял следующие действия: - Запускал сервер разработки - Открывал экземпляр безголового Chromium - Проходил через процесс входа в систему, создания нового чата и создания артефакта - Проверял содержимое DOM, сетевые вызовы и сохраненное состояние

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

К концу испытания описывали частичную, но настоящую копию claude.ai. Непрошенные тесты точно соответствовали отсутствующим или неисправным поведениями, а не абстрактному разочарованию.

Моментум возникает почти сразу. Claude Code, подключенный к долгосрочной системе агентов Anthropic, запускает новый проект, устанавливает зависимости и создает каркас полнофункционального приложения быстрее, чем человек закончит набрасывать архитектуру. В течение первого часа он генерирует фронтенд на React, базовый бекенд API и соединения, необходимые для выполнения сквозных тестов на локальном сервере разработки.

Работа с пользовательским интерфейсом выполняется быстро и уверенно. Агент воссоздает макет в стиле claude.ai: боковая панель для разговоров, основное окно чата и панель артефактов, которая может отображать блоки кода и форматированный текст. Он создаёт заглушки для компонентов пузырьков сообщений, полей ввода и списков разговоров, затем соединяет их с заполнительными данными, чтобы интерфейс казался живым, даже до того, как будет реализована настоящая логика.

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

Следуют низкоуровневые работы по сантехнике. Агент настраивает API маршруты для создания бесед, отправки сообщений и получения истории, затем обновляет фронтенд для их вызова. Типы TypeScript, простая обработка ошибок и конфигурация окружения появляются без запроса, что является побочным эффектом постоянного повторного запуска тестов и вывода трассировок стека.

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

В течение нескольких часов узким местом является не интеллект, а ввод-вывод. Агент больше ждет выполнения `npm install`, тестов браузера и перезапуска сервера разработки, чем ждет идей, прорываясь через легкие 30–40% тестового набора, прежде чем работа действительно станет сложной.

Моментум не обрывается с крахом; он истончается в повторении. После примерно дюжины часов и множества сессий с агентами клон Cole Medin на claude.ai перестает стремительно развиваться и начинает ходить кругами. Новые коммиты по-прежнему появляются, но в основном они просто перекраивают существующую логику, подстраивают селекторы или переименовывают компоненты, не открывая новые проходящие тесты.

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

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

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

По мере того как задачи становятся менее четкими, архитектурная интуиция начинает иметь значение, а у агента её нет. Он может рефакторить компоненты React, переставлять обработчики API и настраивать типы TypeScript, но у него отсутствует ясная ментальная модель всего приложения в стиле claude.ai. Когда потоки в браузере не совпадают с предположениями на стороне сервера, агент реагирует локально, вместо того чтобы переработать поток.

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

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

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

К 24-му часу эксперимент Коула Медина закончился очень нестандартным для Кремниевой долины результатом: «чуть более половины» автоматизированных тестов прошло успешно. Никакого празднования, никакого отполированного клона claude.ai, только постройка, тихо сообщающая, что примерно 50–60% ее собственных спецификаций были выполнены.

Формулируя по-другому, в основном неконтролируемый AI-агент кодирования провел целый день, работая над реальным полностековым приложением, и выпустил что-то, что действительно работает, маршрутизирует и отображает. Для системы с минимальным вмешательством это дикий прогресс по сравнению с эпохой "игрушечного CRUD-приложения в одном запросе", но все же далеко от программного обеспечения производственного уровня.

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

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

Программное обеспечение Cole в значительной степени полагалось на тесты end-to-end на основе браузера, разворачивая безголовую среду и переходя по интерфейсу фальшивого claude.ai. Эти тесты подтверждали реальное поведение — кнопки, модальные окна, сетевые вызовы — а не просто сигнатуры функций, что делало каждое успешное тестирование более значимым, а каждое проваленное испытание труднее игнорировать.

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

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

Кодовые агенты не нуждаются в настроении, им нужны тесты. 24‑часовой марафон Claude Code, проведённый Коулом Медином, остался в рамках разумного только потому, что все важные поведения для клона claude.ai первоначально существовали в виде автоматических проверок. Задача агента заключалась не в «создании приложения», а в «приведении этих тестов к успешному результату», что превращало размытый запрос в чёткий контракт.

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

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

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

TDD также четко отделял намерение от реализации, что почти идеально совпадает с тем, как работают LLM. Человеческие инженеры закодировали ожидания от продукта в тестах Jest и Playwright: «Когда я отправляю сообщение, оно появляется в потоке», «Артефакты открываются в панели с метаданными». Клоду нужно было лишь найти в кодовой базе способы удовлетворить эти утверждения.

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

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

Эксперимент Медина наглядно демонстрирует соотношение. Структурированный TDD в сочетании с хранилищем привел к созданию приложения в стиле claude.ai, где более половины тестов прошли проверку через 24 часа. Рабочие процессы, основанные только на подсказках, редко выдерживают 24 минуты, прежде чем рухнуть в несогласованный, неповторяемый код.

Человеческие усилия в 24-часовом эксперименте Коула Медин не были направлены на написание React-компонентов или настройку классов Tailwind. Они были сосредоточены на определении системы, в которой будет существовать ИИ: структуре репозитория, наборе функций в стиле claude.ai и правилах взаимодействия, которым агент должен был следовать. Как только эта основа была создана, Claude Code стал больше похож на очень быстрого, очень буквального подрядчика, чем на коллегу.

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

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

Будущие разработчики, которые будут процветать в этом мире, будут одержимы формулированием проблем, а не синтаксисом. Они определят:

• 1Проблемное пространство: что приложение должно делать, какие потоки важны, какие крайние случаи имеют значение.
• 2Ограничения: выбор технологий, бюджеты производительности, правила безопасности, точки интеграции.
• 3Критерии успеха: сквозное тестирование, пороги приемки и обязательные условия поведения

Эти решения определили, почему Клод смог пройти «чуть больше половины» тестов и почему он на этом остановился. Отсутствие или неоднозначность тестов означали, что агент не имел стимула исправлять определенные интеграционные ошибки. Слишком размытые цели оставили его в беспорядке при работе с сложными пользовательскими интерфейсами вместо того, чтобы сосредоточиться на основной функциональности.

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

Агентное кодирование больше не существует только в научных статьях и демонстрационных роликах. 24-часовой испытательный марафон Коула Медина ставит долгожданный агентский интерфейс Anthropic в один ряд с GitHub Copilot, Codeium и Replit Ghostwriter — только этот инструмент не просто завершает функцию, он сам проводит целый спринт разработки программного обеспечения. Система создает клон claude.ai, настраивает пользовательские потоки и упорно выполняет тесты от начала до конца на протяжении целых суток.

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

Фреймворки агентов раньше казались игрушками исключительно от DeepMind, скрытыми за внутренними стеками оркестрации. Открытый проект Anthropic claude-code-harness изменяет эту динамику. Теперь одиночный разработчик может создать: - Инициализирующий агент, который определяет спецификации и тесты - Кодирующий агент, который редактирует код и запускает браузеры - Цикл обратной связи, который продолжается более 50 сессий

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

С точки зрения отрасли, это указывает на новый уровень в структуре: "AI build pipelines", которые находятся рядом с CI/CD. Помощники в средах разработки помогают людям печатать быстрее; управляемые агенты выполняют дорожные карты, рефакторят кодовые базы за ночь или без усталости работают над ненадежными интеграционными тестами. 24-часовой запуск Medin выглядит неаккуратно и неполно, но он предвещает ближайшее будущее, где в каждой серьезной инженерной организации будет как минимум один репозиторий, где основным участником является бот.

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

Начните с одной функции, а не с полного клона claude.ai. Выберите что-то вроде "добавить вход через OAuth", "реализовать импорт CSV" или "создать страницу настроек" и определите 3–10 автоматизированных тестов, которые более точно опишут, что значит "сделано", чем любое описание.

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

Репозитории Anthropic предоставляют вам конкретную отправную точку. Долговечный агент, использованный Колом, находится по адресу github.com/anthropics/claude-agentic-coding, а более широкие примеры Claude Code демонстрируют, как соединить редактирование файлов, тестовые исполнители и автоматизацию браузера в одном цикле.

Вам не нужно дублировать более 50 кодировочных сессий Коула или запускать безголовую ферму браузеров с первого дня. Вы можете получить 80% выгоды, позволяя агенту многократно вызывать `pytest`, `npm test` или скрипты Playwright, и только вмешиваться, когда процесс явно застынет или начнёт терять эффективность.

Практический стартовый рецепт выглядит так: - Напишите короткое описание и тесты для одной функции - Передайте ИИ ваш репозиторий, описание и команду тестирования - Позвольте ему итеративно работать, пока тесты не пройдут или прогресс не остановится - Уточняйте тесты, архитектуру или подсказки, затем повторяйте процесс

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

Что такое использование AI-агента?

Среда для AI-агентов — это структура, которая предоставляет AI-модели инструменты, память и организованный цикл (планирование, кодирование, тестирование, доработка) для самостоятельного выполнения сложных и длительных задач, таких как кодирование целого приложения.

Смогла ли ИИ успешно разработать приложение за 24 часа?

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

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

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

Какой ИИ-моделью пользовались в эксперименте?

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