Agentdriven utveckling: Superladda Copilot Applied Science

Automatisering av intellektuellt slit med AI-agenter

I det snabbt föränderliga landskapet inom mjukvaruutveckling leder strävan efter effektivitet ofta till banbrytande innovationer. Tyler McGoffin, en AI-forskare, beskrev nyligen en resa som exemplifierar denna anda: att automatisera sitt intellektuella slit genom agentdriven utveckling med GitHub Copilot. Detta handlar inte bara om snabbare kodning; det handlar om att i grunden flytta utvecklarens roll från repetitiv analys till kreativ problemlösning och strategisk översikt. McGoffins erfarenhet belyser ett välkänt mönster bland ingenjörer – att bygga verktyg för att eliminera tråkigt arbete – men tar det ett steg längre genom att anförtro AI-agenter komplexa analysuppgifter som tidigare var omöjliga att skala manuellt.

McGoffins inspiration härstammade från en kritisk, men överväldigande, aspekt av hans arbete: att analysera kodagenters prestanda mot benchmarks som TerminalBench2 och SWEBench-Pro. Detta innebar att dissekera 'trajektorier' – detaljerade JSON-loggar över en agents tankeprocesser och handlingar – som kunde uppgå till hundratusentals kodrader över många uppgifter och benchmarkkörningar. Medan GitHub Copilot redan assisterade med mönsterigenkänning, skrek den repetitiva naturen av denna analysslinga efter fullständig automatisering. Detta ledde till skapandet av 'eval-agents', ett system utformat för att automatisera denna intellektuella börda, vilket gav hans team inom Copilot Applied Science möjlighet att uppnå liknande effektivitet.

Ritningen för agentdriven utveckling

Ursprunget till 'eval-agents' styrdes av en tydlig uppsättning principer fokuserade på samarbete och skalbarhet. McGoffin strävade efter att göra dessa AI-agenter lätta att dela, enkla att skapa och det primära verktyget för teamets bidrag. Dessa mål speglar GitHubs kärnvärden, särskilt de som finslipats under hans erfarenhet som OSS-ansvarig för GitHub CLI. Det var dock det tredje målet – att göra kodningsagenter till den primära bidragsgivaren – som verkligen formade projektets riktning och låste upp oväntade fördelar för de två första.

Den agentiska kodningsuppsättningen använde flera kraftfulla verktyg för att effektivisera utvecklingsprocessen:

Kodningsagent: Copilot CLI, som erbjuder direkt interaktion och kontroll.
Använd modell: Claude Opus 4.6, som erbjuder avancerade resonemang och kodgenereringsförmågor.
IDE: VSCode, som fungerar som den centrala arbetsytan för utveckling.

Avgörande var att Copilot SDK var avgörande och gav tillgång till befintliga verktyg, MCP-servrar och mekanismer för att registrera nya verktyg och färdigheter. Denna grund eliminerade behovet av att återuppfinna kärnagentfunktioner, vilket gjorde att teamet kunde fokusera på applikationsspecifik logik. Denna integrerade miljö främjade en snabb utvecklingsslinga, vilket bevisade att med rätt inställning kunde AI-agenter inte bara assistera utan också driva betydande delar av utvecklingsarbetet.

Kärnprinciper för effektiv agentisk kodning

Övergången till ett agentdrivet paradigm kräver mer än bara verktyg; det kräver en metodologisk förändring. McGoffin identifierade tre kärnprinciper som visade sig vara grundläggande för att accelerera utvecklingen och främja samarbete:

Promptstrategier: Att interagera effektivt med agenter innebär att vara konversativ, utförlig och prioritera planering.
Arkitektoniska strategier: En ren, väldokumenterad och refaktorerad kodbas är av största vikt för att agenter effektivt ska kunna navigera och bidra till.
Iterationsstrategier: Att anta ett "skyll på processen, inte agenterna"-tankesätt, liknande en skuldfri kultur, möjliggör snabb experimentering och inlärning.

Dessa strategier, när de tillämpades konsekvent, ledde till häpnadsväckande resultat. Som ett bevis på denna effektivitet lade fem nya bidragsgivare, på bara tre dagar, kollektivt till 11 nya agenter, fyra nya färdigheter och introducerade konceptet 'eval-agent workflows' till projektet. Denna kollaborativa sprint resulterade i en anmärkningsvärd ändring på +28 858/-2 884 kodrader över 345 filer, vilket demonstrerar den djupgående inverkan av github-agentic-workflows i praktiken.

Här är en sammanfattning av kärnprinciperna:

Princip	Beskrivning	Fördel för agentdriven utveckling
Promptning	Behandla agenter som erfarna ingenjörer: vägled deras tänkande, överförklara antaganden, utnyttja planeringslägen (`/plan`) före exekvering. Var konversativ och detaljerad.	Leder till mer exakta och relevanta resultat, vilket hjälper agenter att lösa komplexa problem effektivt.
Arkitektur	Prioritera refaktorering, omfattande dokumentation och robust testning. Håll kodbasen ren, läsbar och välstrukturerad. Städa aktivt upp död kod.	Gör det möjligt för agenter att förstå kodbasen, mönster och befintlig funktionalitet, vilket underlättar korrekta bidrag.
Iteration	Anta ett "skyll på processen, inte agenterna"-tankesätt. Implementera skyddsmekanismer (strikt typning, linters, omfattande tester) för att förhindra misstag. Lär av agentfel genom att förbättra processer och skyddsmekanismer.	Främjar snabb iteration, bygger förtroende för agentbidrag och förbättrar kontinuerligt utvecklingspipelinen.

Accelererad utveckling: Strategier i handling

Framgången med detta agentdrivna tillvägagångssätt är rotad i praktisk tillämpning av dessa principer.

Promptstrategier: Vägleda AI-ingenjören

AI-kodagenter, även om de är kraftfulla, utmärker sig i väl avgränsade problem. För mer komplexa uppgifter kräver de vägledning, ungefär som juniora ingenjörer. McGoffin fann att en konversativ stil, förklarande av antaganden och utnyttjande av planeringslägen var mycket effektivare än korta kommandon. Till exempel, när man lade till robusta regressionstester, initierade en prompt som /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? en produktiv dialog. Detta fram och tillbaka, ofta med den kraftfulla claude-opus-4-6 modellen, ledde till sofistikerade lösningar som contract testing guardrails, vilka endast mänskliga ingenjörer kunde uppdatera, vilket säkerställde att kritisk funktionalitet förblev skyddad.

Arkitektoniska strategier: Grunden för AI-assisterad kvalitet

För mänskliga ingenjörer är att upprätthålla en ren kodbas, skriva tester och dokumentera funktioner ofta nedprioriterat under funktionstryck. Inom agentdriven utveckling blir dessa av yttersta vikt. McGoffin upptäckte att att spendera tid på att refaktorisera, dokumentera och lägga till testfall dramatiskt förbättrade Copilots förmåga att navigera och bidra till kodbasen. Ett agent-först-arkiv frodas på tydlighet. Detta gör det möjligt för utvecklare att till och med fråga Copilot med frågor som "Med det jag vet nu, hur skulle jag designa detta annorlunda?", vilket förvandlar teoretiska refaktoreringar till uppnåeliga projekt med AI-assistans. Detta kontinuerliga fokus på arkitektonisk hälsa säkerställer att nya funktioner kan levereras trivialt.

Iterationsstrategier: Att lita på processen, inte bara agenten

Utvecklingen av AI-modeller har skiftat tankesättet från "lita men verifiera" till en mer tillitsfull inställning, analogt med hur effektiva team arbetar med en filosofi som "skyll på processen, inte människorna". Denna "skuldfria kultur" inom agentdriven utveckling innebär att när en AI-agent gör ett misstag, är svaret att förbättra de underliggande processerna och skyddsmekanismerna, snarare än att skylla på agenten själv. Detta innebär att implementera rigorösa CI/CD-metoder: strikt typning för att säkerställa gränssnittskonformitet, robusta linters för kodkvalitet, och omfattande integrations-, end-to-end- och kontraktstester. Även om det kan vara dyrt att bygga dessa tester manuellt, gör agentassistans dem mycket billigare att implementera, vilket ger kritiskt förtroende för nya ändringar. Genom att sätta upp dessa system ger utvecklare Copilot möjlighet att kontrollera sitt eget arbete, vilket speglar hur en junior ingenjör får förutsättningar för framgång.

Bemästra den agentdrivna utvecklingsslingan

Att integrera dessa principer i ett praktiskt arbetsflöde skapar en kraftfull, accelererad utvecklingsslinga:

Planera med Copilot: Initiera nya funktioner med hjälp av /plan. Iterera på planen, säkerställ att tester och dokumentationsuppdateringar inkluderas och slutförs före kodimplementering. Dokumentation kan fungera som ytterligare riktlinjer för agenten.
Implementera med Autopilot: Låt Copilot implementera funktionen med hjälp av /autopilot, utnyttjande dess kodgenereringsförmåga.
Granska med Copilot Code Review: Be Copilot att initiera en granskningsslinga. Detta innebär att begära Copilot Code Review-agenten, hantera dess kommentarer och begära om granskningar tills problemen är lösta.
Mänsklig granskning: Utför en slutlig mänsklig granskning för att säkerställa att mönster efterlevs och att komplexa beslut överensstämmer med strategisk intention.

Utöver funktionsslingan är kontinuerlig optimering avgörande. McGoffin uppmanar regelbundet Copilot med kommandon som /plan Review the code for any missing tests, any tests that may be broken, and dead code eller /plan Review the documentation and code to identify any documentation gaps. Dessa kontroller, som körs veckovis eller när nya funktioner integreras, säkerställer att den agentdrivna utvecklingsmiljön förblir hälsosam och effektiv.

Framtiden för mjukvaruutveckling med AI

Vad som började som en personlig strävan att automatisera en frustrerande analysuppgift har utvecklats till ett nytt paradigm för mjukvaruutveckling. Agentdriven utveckling, driven av verktyg som GitHub Copilot och avancerade modeller som Claude Opus, handlar inte bara om att göra utvecklare snabbare; det handlar om att i grunden förändra arbetets natur för både AI-forskare och mjukvaruingenjörer. Genom att överföra intellektuellt slit till intelligenta agenter kan team uppnå oöverträffade nivåer av produktivitet, samarbete och innovation, och i slutändan fokusera på de kreativa och strategiska utmaningar som verkligen driver framsteg. Detta tillvägagångssätt förebådar en spännande framtid där AI-agenter inte bara är verktyg, utan integrerade medlemmar av utvecklingsteamet, vilket omformar hur vi bygger och underhåller mjukvara.

Originalkälla

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

Vanliga frågor

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.

Håll dig uppdaterad

Få de senaste AI-nyheterna i din inkorg.

Dela