Разработка, управлявана от агенти: Свръхзареждане на приложната наука на Copilot

Автоматизиране на интелектуалния труд с AI агенти

В бързо развиващия се пейзаж на софтуерното инженерство, стремежът към ефективност често води до революционни иновации. Тайлър МакГофин, 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-agentic-workflows на практика.

Ето резюме на основните принципи:

Принцип	Описание	Полза за разработката, управлявана от агенти
Промптиране	Отнасяйте се към агентите като към старши инженери: насочвайте мисленето им, обяснявайте подробно допусканията, използвайте режими за планиране (`/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? инициира продуктивен диалог. Този диалог, често с мощния модел Claude Opus 4.6, доведе до сложни решения като предпазни мерки за тестване на договори, които само човешки инженери можеха да актуализират, гарантирайки, че критичната функционалност остава защитена.

Архитектурни стратегии: Основата на подпомаганото от AI качество

За човешките инженери, поддържането на чиста кодова база, писането на тестове и документирането на функционалности често са с по-нисък приоритет под натиска за нови функционалности. При разработката, управлявана от агенти, те стават от първостепенно значение. МакГофин откри, че отделянето на време за рефакторинг, документиране и добавяне на тестови случаи драстично подобрява способността на Copilot да навигира и да допринася към кодовата база. Хранилище, ориентирано към агенти, процъфтява върху яснотата. Това позволява на разработчиците дори да подканват Copilot с въпроси като "Знаейки това, което знам сега, как бих проектирал това по различен начин?", превръщайки теоретичните рефакторинги в постижими проекти с помощта на AI. Този непрекъснат фокус върху архитектурното здраве гарантира, че новите функционалности могат да бъдат предоставени тривиално.

Стратегии за итерация: Доверяване на процеса, а не само на агента

Еволюцията на AI моделите измести мисленето от "доверявай се, но проверявай" към по-доверчива позиция, аналогична на това как ефективните екипи работят с философия "обвинявай процеса, не хората". Тази "култура без обвинения" при разработката, управлявана от агенти, означава, че когато AI агент допусне грешка, отговорът е да се подобрят основните процеси и предпазни мерки, вместо да се обвинява самият агент. Това включва прилагане на строги CI/CD практики: стриктно типизиране за осигуряване на съответствие на интерфейса, стабилни линтери за качество на кода и обширни интеграционни, end-to-end и договорни тестове. Докато изграждането на тези тестове ръчно може да бъде скъпо, помощта на агентите ги прави много по-евтини за внедряване, осигурявайки критична увереност в новите промени. Чрез настройването на тези системи, разработчиците дават възможност на Copilot да проверява собствената си работа, отразявайки как един младши инженер е настроен за успех.

Овладяване на цикъла на разработка, управлявана от агенти

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

Планирайте с Copilot: Инициирайте нови функционалности, използвайки /plan. Итерирайте плана, като гарантирате, че актуализациите на тестовете и документацията са включени и завършени преди имплементацията на кода. Документацията може да служи като допълнителен набор от насоки за агента.
Имплементирайте с Autopilot: Позволете на 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. Тези проверки, изпълнявани ежеседмично или при интегриране на нови функционалности, гарантират, че средата за разработка, управлявана от агенти, остава здрава и ефективна.

Бъдещето на софтуерното инженерство с AI

Това, което започна като лично търсене за автоматизиране на една разочароваща задача за анализ, се превърна в нова парадигма за разработка на софтуер. Разработката, управлявана от агенти, захранвана от инструменти като GitHub Copilot и усъвършенствани модели като Claude Opus, не е просто за това да направи разработчиците по-бързи; става въпрос за фундаментално променяне на естеството на работа както за AI изследователите, така и за софтуерните инженери. Чрез прехвърляне на интелектуалния труд към интелигентни агенти, екипите могат да постигнат безпрецедентни нива на производителност, сътрудничество и иновации, като в крайна сметка се фокусират върху творческите и стратегически предизвикателства, които наистина движат напредъка. Този подход предвещава вълнуващо бъдеще, в което 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.

Бъдете информирани

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

Сподели