Agent-gedrewe Ontwikkeling: Versnelling van Copilot Toegepaste Wetenskap

Outomatisering van Intellektuele Moeite met KI-agente

In die vinnig-ontwikkelende landskap van sagteware-ingenieurswese, lei die strewe na doeltreffendheid dikwels tot baanbrekende innovasies. Tyler McGoffin, 'n KI-navorser, het onlangs 'n reis beskryf wat hierdie gees tipeer: die outomatisering van sy intellektuele moeite deur middel van agent-gedrewe ontwikkeling met GitHub Copilot. Dit gaan nie net oor vinniger kodering nie; dit gaan oor die fundamentele verskuiwing van die ontwikkelaar se rol van herhalende analise na kreatiewe probleemoplossing en strategiese toesig. McGoffin se ervaring beklemtoon 'n bekende patroon onder ingenieurs—die bou van gereedskap om sleurwerk uit te skakel—maar neem dit 'n stap verder deur KI-agente met komplekse analitiese take toe te vertrou wat voorheen onmoontlik was om handmatig te skaal.

McGoffin se inspirasie het gespruit uit 'n kritieke, dog oorweldigende, aspek van sy werk: die analise van koderingsagentprestasie teen maatstawwe soos TerminalBench2 en SWEBench-Pro. Dit het behels die ontleding van 'trajekte'—gedetailleerde JSON-logboeke van 'n agent se denkprosesse en aksies—wat kon neerkom op honderdduisende reëls kode oor talle take en maatstafuitvoerings. Terwyl GitHub Copilot reeds gehelp het met patroonherkenning, het die herhalende aard van hierdie analitiese lus gesmeek vir volle outomatisering. Dit het gelei tot die skepping van 'eval-agents,' 'n stelsel wat ontwerp is om hierdie intellektuele las te outomatiseer, wat sy span in Copilot Applied Science bemagtig het om soortgelyke doeltreffendhede te bereik.

Die Bloudruk vir Agent-gedrewe Ontwikkeling

Die ontstaan van 'eval-agents' is gelei deur 'n duidelike stel beginsels wat fokus op samewerking en skaalbaarheid. McGoffin het daarna gestreef om hierdie KI-agente maklik deelbaar, eenvoudig om te skryf, en die primêre voertuig vir spanbydraes te maak. Hierdie doelwitte weerspieël GitHub se kernwaardes, veral dié wat geslyp is tydens sy ervaring as 'n OSE-onderhouer vir die GitHub CLI. Dit was egter die derde doelwit—om koderingsagente die primêre bydraer te maak—wat die projek se rigting werklik gevorm het en onverwagte voordele vir die eerste twee ontsluit het.

Die agentiese koderingsopstelling het verskeie kragtige gereedskap benut om die ontwikkelingsproses te stroomlyn:

Koderingsagent: Copilot CLI, wat direkte interaksie en beheer bied.
Model gebruik: Claude Opus 4.6, wat gevorderde redeneer- en kodegenereringsvermoëns bied.
GOE: VSCode, wat dien as die sentrale werkruimte vir ontwikkeling.

Deurslaggewend was die Copilot SDK instrumenteel, wat toegang bied tot bestaande gereedskap, MCP-bedieners, en meganismes om nuwe gereedskap en vaardighede te registreer. Hierdie fondament het die noodsaaklikheid uitgeskakel om kern agentiese funksionaliteite te herontwerp, wat die span in staat gestel het om op toepassingspesifieke logika te fokus. Hierdie geïntegreerde omgewing het 'n vinnige ontwikkelingslus bevorder, wat bewys dat, met die regte opstelling, KI-agente nie net kon assisteer nie, maar ook beduidende gedeeltes van die ontwikkelingspoging kon aandryf.

Kernbeginsels vir Effektiewe Agentiese Kodering

Die oorgang na 'n agent-gedrewe paradigma vereis meer as net gereedskap; dit verg 'n verskuiwing in metodologie. McGoffin het drie kernbeginsels geïdentifiseer wat fundamenteel was vir die versnelling van ontwikkeling en die bevordering van samewerking:

Aanstuurstrategieë: Effektiewe interaksie met agente beteken gespreksgeoriënteerd, breedvoerig en die prioritering van beplanning.
Argitektoniese Strategieë: 'n Skoon, goed gedokumenteerde en herfaktoreerde kodebasis is van die uiterste belang vir agente om effektief te navigeer en daartoe by te dra.
Iterasiestrategieë: Die omhelsing van 'n "proses blameer, nie agente nie"-ingesteldheid, soortgelyk aan 'n blaamlose kultuur, maak vinnige eksperimentering en leer moontlik.

Hierdie strategieë, wanneer dit konsekwent toegepas word, het tot verstommende resultate gelei. As 'n bewys van hierdie doeltreffendheid, het vyf nuwe bydraers, binne net drie dae, gesamentlik 11 nuwe agente, vier nuwe vaardighede bygevoeg, en die konsep van 'eval-agent werkvloeie' aan die projek bekendgestel. Hierdie samewerkende naelloop het gelei tot 'n merkwaardige +28,858/-2,884 reëls kode-verandering oor 345 lêers, wat die diepgaande impak van github-agentic-workflows in die praktyk demonstreer.

Hier is 'n opsomming van die kernbeginsels:

Beginsels	Beskrywing	Voordeel vir Agent-gedrewe Ontwikkeling
Aanstuur	Behandel agente soos senior ingenieurs: lei hul denke, oorverklaar aannames, benut beplanningsmodusse (`/plan`) voor uitvoering. Wees gespreksgeoriënteerd en gedetailleerd.	Lei tot meer akkurate en relevante uitsette, wat agente help om komplekse probleme effektief op te los.
Argitektonies	Prioritiseer herfaktorering, omvattende dokumentasie en robuuste toetsing. Hou die kodebasis skoon, leesbaar en goed gestruktureer. Ruim aktief dooie kode op.	Stel agente in staat om die kodebasis, patrone en bestaande funksionaliteit te verstaan, wat akkurate bydraes fasiliteer.
Iterasie	Pas 'n "proses blameer, nie agente nie"-ingesteldheid toe. Implementeer voorsorgmaatreëls (streng tipering, lintere, uitgebreide toetse) om foute te voorkom. Leer uit agentfoute deur prosesse en voorsorgmaatreëls te verbeter.	Bevorder vinnige iterasie, bou vertroue in agentbydraes, en verbeter voortdurend die ontwikkelingspyplyn.

Versnelling van Ontwikkeling: Strategieë in Aksie

Die sukses van hierdie agent-gedrewe benadering is gewortel in die praktiese toepassing van hierdie beginsels.

Aanstuurstrategieë: Begeleiding van die KI-ingenieur

KI-koderingsagente, hoewel kragtig, blink uit in goed-gedefinieerde probleme. Vir meer komplekse take, benodig hulle leiding, baie soos junior ingenieurs. McGoffin het gevind dat 'n gespreksgeoriënteerde styl, die verduideliking van aannames, en die benutting van beplanningsmodusse baie meer effektief was as bondige opdragte. Byvoorbeeld, toe robuuste regressietoetse bygevoeg is, het 'n prompt soos /plan Ek het onlangs opgemerk hoe Copilot geredelik toetse opdateer om by sy nuwe paradigmas te pas, alhoewel daardie toetse nie opgedateer moes word nie. Hoe kan ek 'n gereserveerde toetsruimte skep wat Copilot nie kan raak nie, of moet reserveer om teen regressies te beskerm? 'n produktiewe dialoog geïnisieer. Hierdie heen-en-weer, dikwels met die kragtige claude-opus-4-6-model, het gelei tot gesofistikeerde oplossings soos kontraktoets-voorsorgmaatreëls, wat slegs menslike ingenieurs kon opdateer, om te verseker dat kritieke funksionaliteit beskerm bly.

Argitektoniese Strategieë: Die Grondslag van KI-ondersteunde Kwaliteit

Vir menslike ingenieurs word die instandhouding van 'n skoon kodebasis, die skryf van toetse en die dokumentasie van kenmerke dikwels agterweë gelaat onder kenmerk-druk. In agent-gedrewe ontwikkeling word dit van die uiterste belang. McGoffin het ontdek dat die spandeer van tyd aan herfaktorering, dokumentasie en die byvoeging van toetsgevalle Copilot se vermoë om die kodebasis te navigeer en daartoe by te dra, dramaties verbeter het. 'n Agent-eerste bewaarplek floreer op duidelikheid. Dit stel ontwikkelaars in staat om selfs Copilot met vrae te prompt soos "As ek nou weet wat ek weet, hoe sou ek dit anders ontwerp?", wat teoretiese herfaktoreerprojekte in uitvoerbare projekte met KI-bystand omskep. Hierdie deurlopende fokus op argitektoniese gesondheid verseker dat nuwe kenmerke met gemak gelewer kan word.

Iterasiestrategieë: Vertrou die Proses, Nie Net die Agent Nie

Die evolusie van KI-modelle het die ingesteldheid verskuif van "vertrou maar verifieer" na 'n meer vertrouende houding, analoog aan hoe effektiewe spanne opereer met 'n "proses blameer, nie mense nie"-filosofie. Hierdie "blaamlose kultuur" in agent-gedrewe ontwikkeling beteken dat wanneer 'n KI-agent 'n fout maak, die reaksie is om die onderliggende prosesse en voorsorgmaatreëls te verbeter, eerder as om die agent self te blameer. Dit behels die implementering van streng CI/CD-praktyke: streng tipering om koppelvlakkonformiteit te verseker, robuuste lintere vir kodekwaliteit, en uitgebreide integrasie-, end-tot-end- en kontraktoetse. Hoewel die handmatige bou van hierdie toetse duur kan wees, maak agentbystand dit veel goedkoper om te implementeer, wat kritiese vertroue in nuwe veranderinge bied. Deur hierdie stelsels op te stel, bemagtig ontwikkelaars Copilot om sy eie werk te kontroleer, wat weerspieël hoe 'n junior ingenieur vir sukses opgestel word.

Beheersing van die Agent-gedrewe Ontwikkelingslus

Die integrasie van hierdie beginsels in 'n praktiese werkvloei skep 'n kragtige, versnelde ontwikkelingslus:

Beplan met Copilot: Begin nuwe kenmerke deur /plan te gebruik. Herhaal die plan en verseker dat toetse en dokumentasie-opdaterings ingesluit en voltooi is voor kode-implementering. Dokumentasie kan dien as 'n bykomende stel riglyne vir die agent.
Implementeer met Autopilot: Laat Copilot die kenmerk implementeer deur /autopilot te gebruik, en benut sy kodegenereringsvermoëns.
Hersien met Copilot Kodehersiening: Prompt Copilot om 'n hersieningslus te begin. Dit behels die aanvra van die Copilot Kodehersieningsagent, die aanspreek van sy kommentaar, en die heraanvra van hersienings totdat probleme opgelos is.
Menslike Hersiening: Voer 'n finale menslike hersiening uit om te verseker dat patrone afgedwing word en komplekse besluite ooreenstem met strategiese bedoeling.

Buite die kenmerklus is deurlopende optimisering die sleutel. McGoffin prompt Copilot gereeld met opdragte soos /plan Hersien die kode vir enige ontbrekende toetse, enige toetse wat gebreek mag wees, en dooie kode of /plan Hersien die dokumentasie en kode om enige dokumentasiegapings te identifiseer. Hierdie kontroles, wat weekliks of soos nuwe kenmerke geïntegreer word, verseker dat die agent-gedrewe ontwikkelingsomgewing gesond en doeltreffend bly.

Die Toekoms van Sagteware-ingenieurswese met KI

Wat begin het as 'n persoonlike soektog om 'n frustrerende ontledings taak te outomatiseer, het ontwikkel tot 'n nuwe paradigma vir sagteware-ontwikkeling. Agent-gedrewe ontwikkeling, aangedryf deur gereedskap soos GitHub Copilot en gevorderde modelle soos Claude Opus, gaan nie net daaroor om ontwikkelaars vinniger te maak nie; dit gaan oor die fundamentele verandering van die aard van werk vir KI-navorsers en sagteware-ingenieurs. Deur intellektuele moeite na intelligente agente af te laai, kan spanne ongekende vlakke van produktiwiteit, samewerking en innovasie bereik, en uiteindelik fokus op die kreatiewe en strategiese uitdagings wat werklik vooruitgang aandryf. Hierdie benadering voorspel 'n opwindende toekoms waar KI-agente nie net gereedskap is nie, maar integrale lede van die ontwikkeling span, wat verander hoe ons sagteware bou en onderhou.

Oorspronklike bron

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

Gereelde Vrae

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.

Bly op hoogte

Kry die nuutste KI-nuus in jou inkassie.

Deel