Agent-gestuurde Ontwikkeling: Copilot Applied Science naar een hoger niveau tillen

Intellectuele inspanning automatiseren met AI-agenten

In het snel evoluerende landschap van software-engineering leidt het streven naar efficiëntie vaak tot baanbrekende innovaties. Tyler McGoffin, een AI-onderzoeker, beschreef onlangs een reis die deze geest belichaamt: het automatiseren van zijn intellectuele inspanning door middel van agent-gestuurde ontwikkeling met GitHub Copilot. Dit gaat niet alleen over sneller coderen; het gaat over het fundamenteel verschuiven van de rol van de ontwikkelaar van repetitieve analyse naar creatieve probleemoplossing en strategisch toezicht. McGoffin's ervaring benadrukt een bekend patroon onder ingenieurs – het bouwen van tools om zwaar werk te elimineren – maar gaat een stap verder door AI-agenten complexe analytische taken toe te vertrouwen die voorheen onmogelijk handmatig te schalen waren.

McGoffin's inspiratie kwam voort uit een kritiek, maar overweldigend aspect van zijn werk: het analyseren van de prestaties van codeeragenten ten opzichte van benchmarks zoals TerminalBench2 en SWEBench-Pro. Dit omvatte het ontleden van 'trajecten'—gedetailleerde JSON-logboeken van de denkprocessen en acties van een agent—die konden oplopen tot honderdduizenden regels code over tal van taken en benchmarkruns. Hoewel GitHub Copilot al hielp bij patroonherkenning, schreeuwde de repetitieve aard van deze analytische lus om volledige automatisering. Dit leidde tot de creatie van 'eval-agents,' een systeem dat is ontworpen om deze intellectuele last te automatiseren, waardoor zijn team bij Copilot Applied Science vergelijkbare efficiëntie kon bereiken.

De blauwdruk voor Agent-gestuurde Ontwikkeling

De start van 'eval-agents' werd geleid door een duidelijke reeks principes gericht op samenwerking en schaalbaarheid. McGoffin wilde deze AI-agenten gemakkelijk deelbaar maken, eenvoudig te creëren en het belangrijkste middel voor team bijdragen. Deze doelstellingen weerspiegelen de kernwaarden van GitHub, met name die welke zijn verfijnd tijdens zijn ervaring als OSS-maintainer voor de GitHub CLI. Het was echter het derde doel – het maken van codeeragenten tot de primaire bijdrager – dat de richting van het project echt heeft gevormd en onverwachte voordelen heeft opgeleverd voor de eerste twee.

De agentische codeeropstelling benutte verschillende krachtige tools om het ontwikkelingsproces te stroomlijnen:

Codeeragent: Copilot CLI, voor directe interactie en controle.
Gebruikt model: Claude Opus 4.6, met geavanceerde redeneer- en codegeneratiecapaciteiten.
IDE: VSCode, dienend als de centrale werkruimte voor ontwikkeling.

Cruciaal was de Copilot SDK instrumenteel, die toegang bood tot bestaande tools, MCP-servers en mechanismen voor het registreren van nieuwe tools en vaardigheden. Deze basis elimineerde de noodzaak om kern agentische functionaliteiten opnieuw uit te vinden, waardoor het team zich kon concentreren op applicatiespecifieke logica. Deze geïntegreerde omgeving bevorderde een snelle ontwikkelingslus, wat bewees dat met de juiste opstelling, AI-agenten niet alleen konden assisteren, maar ook aanzienlijke delen van de ontwikkelingsinspanning konden aansturen.

Kernprincipes voor Effectieve Agentische Codering

De overgang naar een agent-gestuurd paradigma vereist meer dan alleen tooling; het vraagt om een verschuiving in methodologie. McGoffin identificeerde drie kernprincipes die fundamenteel bleken te zijn voor het versnellen van de ontwikkeling en het bevorderen van samenwerking:

Promptingstrategieën: Effectief interacteren met agenten betekent conversatiegericht, uitvoerig zijn en planning prioriteren.
Architecturale Strategieën: Een schone, goed gedocumenteerde en gerefactoreerde codebase is van het grootste belang voor agenten om effectief te kunnen navigeren en bij te dragen.
Iteratiestrategieën: Het omarmen van een 'blame process, not agents'-mentaliteit, vergelijkbaar met een 'blameless culture', maakt snelle experimenten en leren mogelijk.

Deze strategieën leidden, wanneer consequent toegepast, tot verbluffende resultaten. Als bewijs van deze effectiviteit voegden vijf nieuwe bijdragers binnen slechts drie dagen gezamenlijk 11 nieuwe agenten, vier nieuwe vaardigheden toe en introduceerden zij het concept van 'eval-agent workflows' in het project. Deze collaboratieve sprint resulteerde in een opmerkelijke wijziging van +28.858/-2.884 regels code over 345 bestanden, wat de diepgaande impact van github-agentic-workflows in de praktijk aantoont.

Hier is een samenvatting van de kernprincipes:

Principe	Beschrijving	Voordeel voor Agent-gestuurde Ontwikkeling
Prompting	Behandel agenten als senior ingenieurs: begeleid hun denken, leg aannames overmatig uit, benut planningsmodi (`/plan`) vóór uitvoering. Wees conversatiegericht en gedetailleerd.	Leidt tot nauwkeurigere en relevantere outputs, waardoor agenten complexe problemen effectief kunnen oplossen.
Architectuur	Geef prioriteit aan refactoring, uitgebreide documentatie en robuuste tests. Houd de codebase schoon, leesbaar en goed gestructureerd. Ruim actief dode code op.	Stelt agenten in staat de codebase, patronen en bestaande functionaliteit te begrijpen, wat nauwkeurige bijdragen vergemakkelijkt.
Iteratie	Hanteer een "blame process, not agents"-mentaliteit. Implementeer vangnetten (strikte typering, linters, uitgebreide tests) om fouten te voorkomen. Leer van agentfouten door processen en vangnetten te verbeteren.	Bevordert snelle iteratie, bouwt vertrouwen op in agentbijdragen en verbetert continu de ontwikkelingspijplijn.

Ontwikkeling versnellen: Strategieën in actie

Het succes van deze agent-gestuurde aanpak is geworteld in de praktische toepassing van deze principes.

Promptingstrategieën: De AI-ingenieur begeleiden

AI-codeeragenten zijn krachtig, maar excelleren bij goed afgebakende problemen. Voor complexere taken vereisen ze begeleiding, net zoals junior ingenieurs. McGoffin ontdekte dat een conversatiegerichte stijl, het uitleggen van aannames en het benutten van planningsmodi veel effectiever waren dan beknopte commando's. Bijvoorbeeld, bij het toevoegen van robuuste regressietests, initieerde een prompt zoals /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? een productieve dialoog. Dit heen-en-weer, vaak met het krachtige claude-opus-4-6 model, leidde tot geavanceerde oplossingen zoals 'contract testing guardrails', die alleen menselijke ingenieurs konden bijwerken, waardoor cruciale functionaliteit beschermd bleef.

Architecturale Strategieën: De Fundering van AI-ondersteunde Kwaliteit

Voor menselijke ingenieurs worden het onderhouden van een schone codebase, het schrijven van tests en het documenteren van functies vaak gedeprioriteerd onder druk van functies. Bij agent-gestuurde ontwikkeling worden deze van het grootste belang. McGoffin ontdekte dat het besteden van tijd aan refactoring, documenteren en het toevoegen van testgevallen Copilot's vermogen om de codebase te navigeren en eraan bij te dragen dramatisch verbeterde. Een 'agent-first' repository gedijt op duidelijkheid. Dit stelt ontwikkelaars zelfs in staat Copilot te vragen met vragen als 'Knowing what I know now, how would I design this differently?', waardoor theoretische refactors veranderd worden in realiseerbare projecten met AI-ondersteuning. Deze continue focus op architecturale gezondheid zorgt ervoor dat nieuwe functies triviaal kunnen worden geleverd.

Iteratiestrategieën: Het Proces Vertrouwen, Niet Alleen de Agent

De evolutie van AI-modellen heeft de mentaliteit verschoven van 'vertrouw maar verifieer' naar een meer vertrouwende houding, analoog aan hoe effectieve teams opereren met een 'blame process, not people'-filosofie. Deze 'blameless culture' in agent-gestuurde ontwikkeling betekent dat wanneer een AI-agent een fout maakt, de reactie is om de onderliggende processen en vangnetten te verbeteren, in plaats van de agent zelf te beschuldigen. Dit omvat het implementeren van rigoureuze CI/CD-praktijken: strikte typering om interfaceconformiteit te waarborgen, robuuste linters voor codekwaliteit, en uitgebreide integratie-, end-to-end- en contracttests. Hoewel het handmatig bouwen van deze tests duur kan zijn, maakt agentondersteuning ze veel goedkoper te implementeren, wat cruciaal vertrouwen biedt in nieuwe wijzigingen. Door deze systemen op te zetten, stellen ontwikkelaars Copilot in staat om zijn eigen werk te controleren, wat een weerspiegeling is van hoe een junior ingenieur wordt ingesteld op succes.

De Agent-gestuurde Ontwikkelingscyclus Beheersen

Het integreren van deze principes in een praktische workflow creëert een krachtige, versnelde ontwikkelingscyclus:

Plan met Copilot: Start nieuwe functies met behulp van /plan. Herhaal het plan en zorg ervoor dat tests en documentatie-updates zijn opgenomen en voltooid vóór de code-implementatie. Documentatie kan dienen als een aanvullende set richtlijnen voor de agent.
Implementeer met Autopilot: Laat Copilot de functie implementeren met behulp van /autopilot, waarbij het zijn codegeneratiecapaciteiten benut.
Review met Copilot Code Review: Vraag Copilot om een review-lus te starten. Dit omvat het aanvragen van de Copilot Code Review-agent, het behandelen van de opmerkingen en het opnieuw aanvragen van reviews totdat de problemen zijn opgelost.
Menselijke Review: Voer een laatste menselijke review uit om ervoor te zorgen dat patronen worden afgedwongen en complexe beslissingen aansluiten bij de strategische intentie.

Buiten de functielus is continue optimalisatie essentieel. McGoffin vraagt Copilot routinematig met commando's zoals /plan Review the code for any missing tests, any tests that may be broken, and dead code of /plan Review the documentation and code to identify any documentation gaps. Deze controles, wekelijks uitgevoerd of wanneer nieuwe functies worden geïntegreerd, zorgen ervoor dat de agent-gestuurde ontwikkelomgeving gezond en efficiënt blijft.

De Toekomst van Software-engineering met AI

Wat begon als een persoonlijke zoektocht om een frustrerende analysetaak te automatiseren, is geëvolueerd naar een nieuw paradigma voor software-ontwikkeling. Agent-gestuurde ontwikkeling, aangedreven door tools zoals GitHub Copilot en geavanceerde modellen zoals Claude Opus, gaat niet alleen over het sneller maken van ontwikkelaars; het gaat over het fundamenteel veranderen van de aard van het werk voor zowel AI-onderzoekers als software-ingenieurs. Door intellectuele inspanning over te dragen aan intelligente agenten, kunnen teams ongekende niveaus van productiviteit, samenwerking en innovatie bereiken, en zich uiteindelijk richten op de creatieve en strategische uitdagingen die de vooruitgang echt sturen. Deze aanpak luidt een spannende toekomst in waarin AI-agenten niet alleen tools zijn, maar integrale leden van het ontwikkelingsteam, die transformeren hoe we software bouwen en onderhouden.

Originele bron

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

Veelgestelde vragen

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.

Blijf op de hoogte

Ontvang het laatste AI-nieuws in je inbox.