Разработка, управляемая агентами: ускорение прикладных исследований Copilot

Автоматизация интеллектуального труда с помощью AI-агентов

В быстро развивающейся области программной инженерии стремление к эффективности часто приводит к прорывным инновациям. Тайлер МакГоффин, исследователь ИИ, недавно подробно описал путь, который воплощает этот дух: автоматизацию его интеллектуального труда посредством разработки, управляемой агентами, с помощью GitHub Copilot. Это не просто о более быстром написании кода; это о фундаментальном изменении роли разработчика от повторяющегося анализа к творческому решению проблем и стратегическому надзору. Опыт МакГоффина подчеркивает знакомую инженерам закономерность — создание инструментов для устранения рутины, — но идет дальше, доверяя AI-агентам сложные аналитические задачи, которые ранее было невозможно масштабировать вручную.

Вдохновение МакГоффина исходило из критически важного, но подавляющего аспекта его работы: анализ производительности кодирующих агентов по сравнению с бенчмарками, такими как TerminalBench2 и SWEBench-Pro. Это включало разбор 'траекторий' — подробных JSON-журналов мыслительных процессов и действий агента — которые могли составлять сотни тысяч строк кода для множества задач и запусков бенчмарков. Хотя GitHub Copilot уже помогал в распознавании шаблонов, повторяющийся характер этого аналитического цикла требовал полной автоматизации. Это привело к созданию 'eval-agents' — системы, разработанной для автоматизации этой интеллектуальной нагрузки, что позволило его команде в Copilot Applied Science достичь аналогичной эффективности.

Проект разработки, управляемой агентами

Создание 'eval-agents' руководствовалось четким набором принципов, ориентированных на сотрудничество и масштабируемость. МакГоффин стремился сделать этих AI-агентов легко распространяемыми, простыми в создании и основным средством для вклада команды. Эти цели отражают основные ценности GitHub, особенно те, которые были отточены во время его опыта в качестве мейнтейнера OSS для GitHub CLI. Однако именно третья цель — сделать кодирующих агентов основным вкладчиком — действительно сформировала направление проекта и раскрыла неожиданные преимущества для первых двух.

Агентская среда кодирования использовала несколько мощных инструментов для оптимизации процесса разработки:

Кодирующий агент: Copilot CLI, обеспечивающий прямое взаимодействие и контроль.
Используемая модель: Claude Opus 4.6, предлагающая передовые возможности рассуждений и генерации кода.
IDE: VSCode, служащая центральным рабочим пространством для разработки.

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

Основные принципы эффективного агентского кодирования

Переход к парадигме, управляемой агентами, требует не только инструментов; он требует изменения методологии. МакГоффин выделил три основных принципа, которые оказались фундаментальными для ускорения разработки и развития сотрудничества:

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

Эти стратегии, при последовательном применении, привели к поразительным результатам. В подтверждение этой эффективности пять новых участников всего за три дня совместно добавили 11 новых агентов, четыре новых навыка и внедрили концепцию 'рабочих процессов eval-agent' в проект. Этот совместный спринт привел к замечательному изменению в +28 858/-2 884 строк кода в 345 файлах, демонстрируя глубокое влияние рабочих процессов с агентами GitHub на практике.

Вот краткое изложение основных принципов:

Принцип	Описание	Польза для разработки, управляемой агентами
Промптинг	Относитесь к агентам как к старшим инженерам: направляйте их мышление, чрезмерно объясняйте предположения, используйте режимы планирования (`/plan`) перед выполнением. Будьте разговорчивы и детализированы.	Приводит к более точным и релевантным результатам, помогая агентам эффективно решать сложные проблемы.
Архитектурный	Приоритизируйте рефакторинг, всеобъемлющее документирование и надежное тестирование. Поддерживайте кодовую базу чистой, читаемой и хорошо структурированной. Активно удаляйте мертвый код.	Позволяет агентам понимать кодовую базу, шаблоны и существующую функциональность, способствуя точным вкладам.
Итерация	Примите подход 'обвиняй процесс, а не агентов'. Внедряйте меры защиты (строгая типизация, линтеры, обширные тесты) для предотвращения ошибок. Учитесь на ошибках агентов, улучшая процессы и меры защиты.	Способствует быстрой итерации, укрепляет доверие к вкладам агентов и постоянно улучшает конвейер разработки.

Ускорение разработки: стратегии в действии

Успех этого агентского подхода коренится в практическом применении этих принципов.

Стратегии промптинга: Направляя AI-инженера

AI-агенты для кодирования, хотя и мощные, отлично справляются с четко определенными задачами. Для более сложных задач им требуется руководство, очень похожее на то, как младшим инженерам. МакГоффин обнаружил, что использование разговорного стиля, объяснение предположений и использование режимов планирования были гораздо более эффективными, чем краткие команды. Например, при добавлении надежных регрессионных тестов промпт, такой как /plan I've recently observed Copilot happily updating tests to fit its new paradigms even though those tests shouldn't be updated. How can I create a reserved test space that Copilot can't touch or must reserve to protect against regressions? (план: 'Я недавно заметил, что Copilot с удовольствием обновляет тесты, чтобы они соответствовали его новым парадигмам, хотя эти тесты не должны обновляться. Как я могу создать зарезервированное тестовое пространство, к которому Copilot не сможет прикоснуться или должен зарезервировать его для защиты от регрессий?'), инициировал продуктивный диалог. Этот диалог, часто с мощной моделью Claude Opus 4.6, привел к сложным решениям, таким как меры защиты контрактного тестирования, которые могли обновлять только инженеры-люди, гарантируя защиту критической функциональности.

Архитектурные стратегии: Основа качества, управляемого ИИ

Для инженеров-людей поддержание чистой кодовой базы, написание тестов и документирование функций часто отходят на второй план под давлением новых функций. В разработке, управляемой агентами, это становится первостепенным. МакГоффин обнаружил, что время, потраченное на рефакторинг, документирование и добавление тестовых случаев, значительно улучшило способность Copilot ориентироваться в кодовой базе и вносить в нее свой вклад. Репозиторий, ориентированный на агентов, процветает благодаря ясности. Это позволяет разработчикам даже задавать Copilot вопросы, такие как "Зная то, что я знаю сейчас, как бы я спроектировал это по-другому?", превращая теоретические рефакторинги в достижимые проекты с помощью ИИ. Этот постоянный акцент на архитектурное здоровье гарантирует, что новые функции могут быть доставлены тривиально.

Стратегии итерации: Доверять процессу, а не только агенту

Эволюция моделей ИИ изменила мышление с 'доверяй, но проверяй' на более доверительное, аналогично тому, как эффективные команды работают с философией 'обвиняй процесс, а не людей'. Эта 'культура без обвинений' в разработке, управляемой агентами, означает, что когда AI-агент совершает ошибку, реакция состоит в улучшении базовых процессов и мер защиты, а не в обвинении самого агента. Это включает внедрение строгих практик CI/CD: строгую типизацию для обеспечения соответствия интерфейсов, надежные линтеры для качества кода и обширные интеграционные, сквозные и контрактные тесты. Хотя создание этих тестов вручную может быть дорогостоящим, помощь агентов значительно снижает их стоимость, обеспечивая критически важную уверенность в новых изменениях. Настраивая эти системы, разработчики дают Copilot возможность проверять свою работу, отражая, как младший инженер настраивается на успех.

Освоение цикла разработки, управляемой агентами

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

Планируйте с Copilot: Инициируйте новые функции с помощью /plan. Итерируйте по плану, убеждаясь, что тесты и обновления документации включены и завершены до реализации кода. Документация может служить дополнительным набором рекомендаций для агента.
Реализуйте с Автопилотом: Позвольте Copilot реализовать функцию с помощью /autopilot, используя его возможности генерации кода.
Ревью с Copilot Code Review: Предложите Copilot инициировать цикл ревью. Это включает запрос агента Copilot Code Review, устранение его комментариев и повторный запрос ревью до тех пор, пока проблемы не будут решены.
Человеческое ревью: Проведите окончательное человеческое ревью, чтобы убедиться, что шаблоны соблюдаются, а сложные решения соответствуют стратегическим намерениям.

Помимо цикла функций, ключевым является постоянная оптимизация. МакГоффин регулярно предлагает Copilot команды, такие как /plan Review the code for any missing tests, any tests that may be broken, and dead code (план: 'Проверь код на наличие пропущенных тестов, любых тестов, которые могут быть сломаны, и мертвого кода') или /plan Review the documentation and code to identify any documentation gaps. (план: 'Проверь документацию и код, чтобы выявить любые пробелы в документации'). Эти проверки, выполняемые еженедельно или по мере интеграции новых функций, гарантируют, что среда разработки, управляемая агентами, остается здоровой и эффективной.

Будущее программной инженерии с ИИ

То, что начиналось как личный квест по автоматизации утомительной аналитической задачи, превратилось в новую парадигму разработки программного обеспечения. Разработка, управляемая агентами, на базе таких инструментов, как GitHub Copilot, и передовых моделей, таких как Claude Opus, не просто делает разработчиков быстрее; она фундаментально меняет характер работы как для исследователей ИИ, так и для инженеров-программистов. Передавая интеллектуальный труд интеллектуальным агентам, команды могут достичь беспрецедентных уровней производительности, сотрудничества и инноваций, в конечном итоге сосредоточившись на творческих и стратегических задачах, которые действительно движут прогресс. Этот подход предвещает захватывающее будущее, где AI-агенты являются не просто инструментами, а неотъемлемыми членами команды разработчиков, преобразуя то, как мы создаем и поддерживаем программное обеспечение.

Первоисточник

https://github.blog/ai-and-ml/github-copilot/agent-driven-development-in-copilot-applied-science/

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

What is agent-driven development in the context of GitHub Copilot?

Agent-driven development refers to a software engineering paradigm where AI agents, such as those powered by GitHub Copilot, become primary contributors and collaborators in the development process. Instead of merely suggesting code, these agents actively participate in planning, implementing, refactoring, testing, and documenting software. This approach leverages the AI's ability to automate repetitive intellectual tasks, allowing human engineers to focus on higher-level problem-solving, strategic design, and creative work, thereby accelerating development cycles and improving code quality through structured AI assistance and rigorous guardrails.

How did the 'eval-agents' project originate?

The 'eval-agents' project was born out of a common challenge faced by AI researchers: analyzing vast quantities of data. Tyler McGoffin, an AI researcher, found himself repeatedly poring over hundreds of thousands of lines of 'trajectories'—detailed logs of AI agent thought processes and actions during benchmark evaluations. Recognizing this as an intellectually toilsome and repetitive task, he sought to automate it. By applying agent-driven development principles with GitHub Copilot, he created 'eval-agents' to analyze these trajectories, significantly reducing the manual effort required and transforming a tedious analytical chore into an automated process.

What are the key components of an agentic coding setup for this approach?

An effective agentic coding setup, as demonstrated in this approach, typically includes a powerful AI coding agent like Copilot CLI, a robust underlying large language model such as Claude Opus 4.6, and a feature-rich Integrated Development Environment (IDE) like VSCode. Crucially, leveraging an SDK, such as the Copilot SDK, provides access to essential tools, servers, and mechanisms for registering new tools and skills, offering a foundational infrastructure for building and deploying agents without reinventing core functionalities. This integrated environment enables seamless interaction between the developer and the AI agent throughout the development lifecycle.

What prompting strategies are most effective when working with AI coding agents?

Effective prompting strategies for AI coding agents emphasize conversational, verbose, and planning-oriented interactions. Rather than terse problem statements, developers achieve better results by engaging agents in a dialogue, over-explaining assumptions, and leveraging the AI's speed for initial planning before committing to code changes. This involves using planning modes (e.g., '/plan') to collaboratively brainstorm solutions and refine ideas. Treating the AI agent like a junior engineer who benefits from clear guidance, context, and iterative feedback helps it to produce more accurate and relevant outputs, leading to superior problem-solving and feature implementation.

Why are architectural strategies like refactoring and documentation crucial for agent-driven development?

Architectural strategies like frequent refactoring, comprehensive documentation, and robust testing are paramount in agent-driven development because they create a clean, navigable codebase that AI agents can effectively understand and interact with. A well-maintained codebase, much like for human engineers, allows AI agents to contribute features more accurately and efficiently. By prioritizing readability, consistent patterns, and up-to-date documentation, developers ensure that Copilot can interpret the codebase's intent, identify opportunities for improvement, and implement changes with minimal errors, making feature delivery trivial and facilitating continuous re-architecture.

How does a 'blameless culture' apply to iteration strategies in agent-driven development?

Applying a 'blameless culture' to agent-driven development means shifting from a 'trust but verify' mindset to one that prioritizes 'blame process, not agents.' This philosophy acknowledges that AI agents, like human engineers, can make mistakes. The focus then shifts to implementing robust processes and guardrails—such as strict typing, comprehensive linters, and extensive integration and end-to-end tests—to prevent errors. When an agent does make a mistake, the response is to learn from it and introduce additional guardrails, refining the processes and prompts to ensure the same error isn't repeated, fostering a rapid and psychologically safe iteration pipeline.

What is the typical development loop when using agent-driven development?

The typical development loop in agent-driven development begins with planning a new feature collaboratively with Copilot using a '/plan' prompt, ensuring testing and documentation updates are integrated early. Next, Copilot implements the feature, often using an '/autopilot' command. Following implementation, a review loop is initiated with a Copilot Code Review agent, addressing comments iteratively. The final stage involves a human review to enforce patterns and standards. Outside this feature loop, Copilot is periodically prompted to review for missing tests, code duplication, or documentation gaps, maintaining a continuously optimized agent-driven environment.

What kind of impact did agent-driven development have on team productivity and collaboration?

The impact of agent-driven development on team productivity and collaboration was transformative, leading to an incredibly rapid iteration pipeline. In one instance, a team of five new contributors, using this methodology, created 11 new agents, four new skills, and implemented complex workflows in less than three days. This amounted to a staggering change of +28,858/-2,884 lines of code across 345 files. This dramatic increase in output highlights how agent-driven development, by automating routine tasks and providing intelligent assistance, significantly accelerates feature delivery, fosters deeper collaboration, and enables teams to achieve unprecedented levels of innovation and efficiency.

Будьте в курсе

Получайте последние новости ИИ на почту.