Ügynök-vezérelt fejlesztés: A Copilot Alkalmazott Tudomány felpörgetése

Szellemi munka automatizálása AI ügynökökkel

A szoftverfejlesztés gyorsan fejlődő világában a hatékonyságra való törekvés gyakran úttörő innovációkhoz vezet. Tyler McGoffin, AI kutató, a közelmúltban részletezte azt az utazást, amely ezt a szellemet példázza: szellemi munkájának automatizálását ügynök-vezérelt fejlesztésen keresztül a GitHub Copilottal. Ez nem csupán gyorsabb kódolásról szól; alapvetően megváltoztatja a fejlesztő szerepét az ismétlődő elemzéstől a kreatív problémamegoldás és stratégiai felügyelet felé. McGoffin tapasztalata az mérnökök körében ismerős mintát mutat be – eszközök építése a robotmunka kiküszöbölésére – de egy lépéssel tovább viszi, mivel az AI ügynökökre bízza a komplex analitikai feladatokat, amelyeket korábban lehetetlen volt manuálisan skálázni.

McGoffin inspirációja munkájának egy kritikus, mégis túlterhelő aspektusából fakadt: a kódoló ügynökök teljesítményének elemzése olyan benchmarkok ellen, mint a TerminalBench2 és a SWEBench-Pro. Ez 'trajektóriák' – egy ügynök gondolkodási folyamatainak és műveleteinek részletes JSON naplói – boncolgatását jelentette, ami több százezer sornyi kódot tehetett ki számos feladat és benchmark futás során. Bár a GitHub Copilot már segített a mintafelismerésben, ennek az analitikai ciklusnak az ismétlődő jellege teljes automatizálásért kiáltott. Ez vezetett az 'eval-agents' létrehozásához, egy rendszerhez, amelyet e szellemi terhelés automatizálására terveztek, lehetővé téve csapatának a Copilot Alkalmazott Tudomány területén hasonló hatékonyság elérését.

Az ügynök-vezérelt fejlesztés terve

Az 'eval-agents' létrejöttét a együttműködésre és skálázhatóságra fókuszáló, világos elvek vezérelték. McGoffin célja az volt, hogy ezek az AI ügynökök könnyen megoszthatók, egyszerűen elkészíthetők legyenek, és a csapat hozzájárulásainak elsődleges eszközei legyenek. Ezek a célok tükrözik a GitHub alapvető értékeit, különösen azokat, amelyeket az OSS karbantartójaként szerzett tapasztalatai során finomított a GitHub CLI számára. Azonban a harmadik cél – a kódoló ügynökök elsődleges közreműködővé tétele – az volt, ami valóban meghatározta a projekt irányát, és váratlan előnyöket hozott az első kettő számára.

Az ügynök-alapú kódolási beállítás több hatékony eszközt használt a fejlesztési folyamat racionalizálásához:

Kódoló ügynök: Copilot CLI, közvetlen interakciót és vezérlést biztosítva.
Használt modell: Claude Opus 4.6, fejlett érvelési és kódgenerálási képességeket kínálva.
IDE: VSCode, a fejlesztés központi munkaterületeként szolgálva.

Kulcsfontosságú, hogy a Copilot SDK alapvető szerepet játszott, hozzáférést biztosítva a meglévő eszközökhöz, MCP szerverekhez és mechanizmusokhoz új eszközök és készségek regisztrálásához. Ez az alap megkímélte a csapatot az alapvető ügynök-funkcionalitások újrafeltalálásásától, lehetővé téve számukra, hogy az alkalmazás-specifikus logikára összpontosítsanak. Ez az integrált környezet gyors fejlesztési ciklust eredményezett, bizonyítva, hogy a megfelelő beállítással az AI ügynökök nemcsak segíthetnek, hanem jelentős mértékben előre is mozdíthatják a fejlesztési munkát.

Az effektív ügynök-alapú kódolás alapelvei

Az ügynök-vezérelt paradigmára való áttérés többet igényel, mint puszta eszközöket; módszertani változást követel. McGoffin három alapvető elvet azonosított, amelyek alapvetőnek bizonyultak a fejlesztés felgyorsításában és az együttműködés ösztönzésében:

Promptolási stratégiák: Az ügynökökkel való hatékony interakció azt jelenti, hogy beszélgetés-alapúak, bőbeszédűek és a tervezést helyezik előtérbe.
Architekturális stratégiák: A tiszta, jól dokumentált és refaktorált kódbázis kulcsfontosságú ahhoz, hogy az ügynökök hatékonyan navigálhassanak benne és hozzájáruljanak ahhoz.
Iterációs stratégiák: A 'folyamatot hibáztassa, ne az ügynököket' szemléletmód elfogadása, hasonlóan egy hibátlan kultúrához, lehetővé teszi a gyors kísérletezést és tanulást.

Ezek a stratégiák, következetesen alkalmazva, megdöbbentő eredményekhez vezettek. Ennek hatékonyságát bizonyítva, öt új közreműködő, mindössze három nap alatt, együttesen 11 új ügynököt, négy új képességet adott hozzá, és bevezette az 'eval-agent munkafolyamatok' koncepcióját a projektbe. Ez a kollaboratív sprint figyelemre méltó +28,858/-2,884 sornyi kód változást eredményezett 345 fájlban, bemutatva a github-ügynök-alapú-munkafolyamatok mélyreható hatását a gyakorlatban.

Íme az alapelvek összefoglalása:

Alapelv	Leírás	Előny az ügynök-vezérelt fejlesztés számára
Promptolás	Kezelje az ügynököket vezető mérnökként: vezesse gondolkodásukat, magyarázza túl a feltételezéseket, használja ki a tervezési módokat (`/plan`) a végrehajtás előtt. Legyen beszélgetés-alapú és részletes.	Pontosabb és relevánsabb kimenetekhez vezet, segítve az ügynököket a komplex problémák hatékony megoldásában.
Architekturális	Helyezze előtérbe a refaktorálást, az átfogó dokumentációt és a robusztus tesztelést. Tartsa a kódbázist tisztán, olvashatóan és jól strukturáltan. Aktívan tisztítsa meg az elhalt kódot.	Lehetővé teszi az ügynökök számára, hogy megértsék a kódbázist, a mintákat és a meglévő funkcionalitást, elősegítve a pontos hozzájárulásokat.
Iteráció	Fogadja el a 'folyamatot hibáztassa, ne az ügynököket' szemléletmódot. Implementáljon védőkorlátokat (szigorú típusok, linterek, kiterjedt tesztek) a hibák megelőzésére. Tanuljon az ügynökhibákból a folyamatok és védőkorlátok javításával.	Elősegíti a gyors iterációt, növeli az ügynök hozzájárulásokba vetett bizalmat, és folyamatosan javítja a fejlesztési folyamatot.

Fejlesztés gyorsítása: Stratégiák a gyakorlatban

Ennek az ügynök-vezérelt megközelítésnek a sikere ezen elvek gyakorlati alkalmazásában gyökerezik.

Promptolási stratégiák: Az AI mérnök irányítása

Az AI kódoló ügynökök, bár erősek, kiválóan teljesítenek jól meghatározott problémák esetén. Komplexebb feladatokhoz irányításra van szükségük, akárcsak a junior mérnököknek. McGoffin azt tapasztalta, hogy a beszélgetés-alapú stílus, a feltételezések magyarázata és a tervezési módok kihasználása sokkal hatékonyabb volt, mint a tömör parancsok. Például, amikor robusztus regressziós teszteket adott hozzá, egy olyan prompt, mint a /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? produktív párbeszédet indított. Ez az oda-vissza kommunikáció, gyakran az erőteljes claude-opus-4-6 modellel, kifinomult megoldásokhoz vezetett, mint például a szerződéses tesztelési védőkorlátok, amelyeket csak emberi mérnökök frissíthettek, biztosítva a kritikus funkcionalitás védelmét.

Architekturális stratégiák: Az AI-asszisztált minőség alapja

Az emberi mérnökök számára a tiszta kódbázis fenntartása, a tesztek írása és a funkciók dokumentálása gyakran háttérbe szorul a funkciófejlesztés nyomása alatt. Az ügynök-vezérelt fejlesztésben ezek válnak a legfontosabbá. McGoffin felfedezte, hogy a refaktorálásra, dokumentálásra és tesztesetek hozzáadására fordított idő drámaian javította a Copilot képességét, hogy navigáljon a kódbázisban és hozzájáruljon ahhoz. Az ügynök-központú repository a tisztaságra épül. Ez lehetővé teszi a fejlesztők számára, hogy akár olyan kérdéseket is feltegyenek a Copilotnak, mint "Tudván, amit most tudok, hogyan tervezném ezt másként?", elméleti refaktorálásokat AI segítséggel megvalósítható projektekké alakítva. Ez az építészeti egészségre való folyamatos fókusz biztosítja, hogy az új funkciók könnyedén szállíthatók legyenek.

Iterációs stratégiák: Bízni a folyamatban, nem csak az ügynökben

Az AI modellek fejlődése eltolta a szemléletmódot a 'bizalom, de ellenőrzés' elvétől egy bizakodóbb hozzáállás felé, hasonlóan ahhoz, ahogy a hatékony csapatok a 'folyamatot hibáztassa, ne az embereket' filozófia szerint működnek. Ez a 'hibátlan kultúra' az ügynök-vezérelt fejlesztésben azt jelenti, hogy amikor egy AI ügynök hibázik, a válasz az alapul szolgáló folyamatok és védőkorlátok javítása, nem pedig az ügynök hibáztatása. Ez magában foglalja szigorú CI/CD gyakorlatok bevezetését: szigorú típuskezelés az interfész megfelelőségének biztosítására, robusztus linterek a kódminőséghez, valamint kiterjedt integrációs, végpontok közötti és szerződéses tesztek. Bár ezeknek a teszteknek a manuális elkészítése költséges lehet, az ügynök segítsége sokkal olcsóbbá teszi a megvalósításukat, kritikus bizalmat adva az új változtatásokba. Ezen rendszerek felállításával a fejlesztők feljogosítják a Copilotot, hogy ellenőrizze saját munkáját, tükrözve azt, ahogyan egy junior mérnököt felkészítenek a sikerre.

Az ügynök-vezérelt fejlesztési ciklus elsajátítása

Ezen elvek gyakorlati munkafolyamatba integrálása egy erőteljes, felgyorsított fejlesztési ciklust hoz létre:

Tervezés a Copilottal: Indítson új funkciókat a /plan segítségével. Iterálja a tervet, biztosítva, hogy a tesztek és a dokumentációfrissítések beépüljenek és elkészüljenek a kód implementálása előtt. A dokumentáció további iránymutatásként szolgálhat az ügynök számára.
Implementálás Autopilottal: Engedélyezze a Copilotnak a funkció implementálását a /autopilot segítségével, kihasználva a kódgenerálási képességeit.
Felülvizsgálat Copilot Kódellenőrzővel: Kérje meg a Copilotot egy felülvizsgálati ciklus elindítására. Ez magában foglalja a Copilot Kódellenőrző ügynök kérését, annak megjegyzéseinek kezelését, és a felülvizsgálatok újbóli kérését a problémák megoldásáig.
Emberi felülvizsgálat: Végezzen végső emberi felülvizsgálatot a minták betartatásának és a komplex döntések stratégiai szándékkal való összehangolásának biztosítása érdekében.

A funkcióciklusokon túl a folyamatos optimalizálás kulcsfontosságú. McGoffin rendszeresen promptolja a Copilotot olyan parancsokkal, mint a /plan Review the code for any missing tests, any tests that may be broken, and dead code vagy /plan Review the documentation and code to identify any documentation gaps. Ezek az ellenőrzések, hetente vagy új funkciók integrálásakor futtatva, biztosítják, hogy az ügynök-vezérelt fejlesztési környezet egészséges és hatékony maradjon.

A szoftverfejlesztés jövője AI-val

Ami egy személyes küldetésként indult egy frusztráló elemzési feladat automatizálására, az a szoftverfejlesztés új paradigmájává fejlődött. Az ügynök-vezérelt fejlesztés, amelyet olyan eszközök, mint a GitHub Copilot és olyan fejlett modellek, mint a Claude Opus működtetnek, nem csupán a fejlesztők gyorsabbá tételéről szól; alapvetően megváltoztatja az AI kutatók és szoftverfejlesztők munkájának jellegét. A szellemi munka intelligens ügynökökre való áthárításával a csapatok soha nem látott szintű termelékenységet, együttműködést és innovációt érhetnek el, végső soron a kreatív és stratégiai kihívásokra összpontosítva, amelyek valóban előreviszik a fejlődést. Ez a megközelítés izgalmas jövőt hirdet, ahol az AI ügynökök nem csupán eszközök, hanem a fejlesztőcsapat szerves részei, átalakítva, hogyan építjük és tartjuk karban a szoftvereket.

Eredeti forrás

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

Gyakran ismételt kérdések

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.

Maradjon naprakész

Kapja meg a legfrissebb AI híreket e-mailben.

Megosztás