Code Velocity
Entwicklerwerkzeuge

Agentengesteuerte Entwicklung: Copilot Applied Science aufladen

·7 Min. Lesezeit·GitHub·Originalquelle
Teilen
Screenshot, der die agentengesteuerte Entwicklungsoberfläche von GitHub Copilot zeigt, mit Codevorschlägen und kollaborativen Codierungs-Workflows.

Intellektuelle Mühsal mit KI-Agenten automatisieren

In der sich schnell entwickelnden Landschaft der Softwareentwicklung führt das Streben nach Effizienz oft zu bahnbrechenden Innovationen. Tyler McGoffin, ein KI-Forscher, beschrieb kürzlich eine Reise, die diesen Geist verkörpert: die Automatisierung seiner intellektuellen Mühsal durch agentengesteuerte Entwicklung mit GitHub Copilot. Hierbei geht es nicht nur um schnelleres Programmieren; es geht darum, die Rolle des Entwicklers grundlegend von repetitiver Analyse zu kreativer Problemlösung und strategischer Überwachung zu verlagern. McGoffins Erfahrung verdeutlicht ein bekanntes Muster unter Ingenieuren – Werkzeuge zu bauen, um Plackerei zu eliminieren – geht aber noch einen Schritt weiter, indem er KI-Agenten komplexe analytische Aufgaben anvertraut, die zuvor manuell nicht skalierbar waren.

McGoffins Inspiration entsprang einem kritischen, aber überwältigenden Aspekt seiner Arbeit: der Analyse der Leistung von Codierungsagenten anhand von Benchmarks wie TerminalBench2 und SWEBench-Pro. Dies umfasste die Zerlegung von 'Trajektorien' – detaillierten JSON-Protokollen der Denkprozesse und Aktionen eines Agenten –, die sich auf Hunderttausende von Codezeilen über zahlreiche Aufgaben und Benchmark-Läufe summieren konnten. Während GitHub Copilot bereits bei der Mustererkennung half, verlangte die repetitive Natur dieser Analyseschleife nach vollständiger Automatisierung. Dies führte zur Schaffung von 'eval-agents', einem System, das darauf ausgelegt ist, diese intellektuelle Last zu automatisieren und sein Team in Copilot Applied Science zu befähigen, ähnliche Effizienzen zu erzielen.

Der Bauplan für agentengesteuerte Entwicklung

Die Entstehung von 'eval-agents' wurde von klaren Prinzipien geleitet, die auf Zusammenarbeit und Skalierbarkeit abzielten. McGoffin wollte diese KI-Agenten leicht teilbar, einfach zu erstellen und zum primären Vehikel für Teambeiträge machen. Diese Ziele spiegeln die Kernwerte von GitHub wider, insbesondere jene, die er während seiner Erfahrung als OSS-Maintainer für die GitHub CLI verfeinert hatte. Es war jedoch das dritte Ziel – Codierungsagenten zum primären Beitragenden zu machen –, das die Richtung des Projekts wirklich prägte und unerwartete Vorteile für die ersten beiden freischaltete.

Die agentenbasierte Code-Einrichtung nutzte mehrere leistungsstarke Tools, um den Entwicklungsprozess zu optimieren:

  • Codierungsagent: Copilot CLI, für direkte Interaktion und Kontrolle.
  • Verwendetes Modell: Claude Opus 4.6, das fortschrittliche Denk- und Codegenerierungsfähigkeiten bietet.
  • IDE: VSCode, das als zentraler Arbeitsbereich für die Entwicklung dient.

Entscheidend war das Copilot SDK, das Zugang zu bestehenden Tools, MCP-Servern und Mechanismen zur Registrierung neuer Tools und Fähigkeiten bot. Diese Grundlage eliminierte die Notwendigkeit, agentenbasierte Kernfunktionalitäten neu zu erfinden, und ermöglichte dem Team, sich auf anwendungsspezifische Logik zu konzentrieren. Diese integrierte Umgebung förderte einen schnellen Entwicklungszyklus und bewies, dass KI-Agenten mit der richtigen Einrichtung nicht nur unterstützen, sondern auch wesentliche Teile des Entwicklungsaufwands vorantreiben konnten.

Kernprinzipien für effektives agentenbasiertes Codieren

Der Übergang zu einem agentengesteuerten Paradigma erfordert mehr als nur Werkzeuge; er verlangt einen Methodenwechsel. McGoffin identifizierte drei Kernprinzipien, die sich als grundlegend für die Beschleunigung der Entwicklung und die Förderung der Zusammenarbeit erwiesen:

  1. Prompting-Strategien: Effektive Interaktion mit Agenten bedeutet, konversationsorientiert, ausführlich und planungszentriert zu sein.
  2. Architektonische Strategien: Eine saubere, gut dokumentierte und refaktorisierte Codebasis ist von größter Bedeutung, damit Agenten sie effektiv navigieren und dazu beitragen können.
  3. Iterationsstrategien: Die Annahme einer "den Prozess verantwortlich machen, nicht die Agenten"-Mentalität, ähnlich einer fehlerverzeihenden Kultur, ermöglicht schnelles Experimentieren und Lernen.

Diese Strategien führten, konsequent angewendet, zu erstaunlichen Ergebnissen. Als Beweis für diese Wirksamkeit fügten fünf neue Mitwirkende innerhalb von nur drei Tagen gemeinsam 11 neue Agenten, vier neue Fähigkeiten hinzu und führten das Konzept der 'eval-agent workflows' in das Projekt ein. Dieser kollaborative Sprint führte zu einer bemerkenswerten Änderung von +28.858/-2.884 Zeilen Code über 345 Dateien hinweg, was den tiefgreifenden Einfluss von github-agentic-workflows in der Praxis demonstriert.

Hier ist eine Zusammenfassung der Kernprinzipien:

PrinzipBeschreibungNutzen für agentengesteuerte Entwicklung
PromptingBehandle Agenten wie Senior-Ingenieure: leite ihr Denken, erkläre Annahmen überausführlich, nutze Planungsmodi (/plan) vor der Ausführung. Sei konversationsfreudig und detailliert.Führt zu genaueren und relevanteren Ergebnissen und hilft Agenten, komplexe Probleme effektiv zu lösen.
ArchitekturPriorisiere Refactoring, umfassende Dokumentation und robuste Tests. Halte die Codebasis sauber, lesbar und gut strukturiert. Bereinige aktiv toten Code.Ermöglicht Agenten, die Codebasis, Muster und bestehende Funktionalitäten zu verstehen, was präzise Beiträge erleichtert.
IterationVerfolge eine 'den Prozess verantwortlich machen, nicht die Agenten'-Mentalität. Implementiere Leitplanken (strikte Typisierung, Linter, umfangreiche Tests), um Fehler zu vermeiden. Lerne aus Agentenfehlern, indem du Prozesse und Leitplanken verbesserst.Fördert schnelle Iteration, schafft Vertrauen in Agentenbeiträge und verbessert kontinuierlich die Entwicklungspipeline.

Entwicklung beschleunigen: Strategien in Aktion

Der Erfolg dieses agentengesteuerten Ansatzes wurzelt in der praktischen Anwendung dieser Prinzipien.

Prompting-Strategien: Den KI-Ingenieur leiten

KI-Codierungsagenten sind zwar leistungsfähig, aber sie brillieren bei klar abgegrenzten Problemen. Für komplexere Aufgaben benötigen sie Anleitung, ähnlich wie Junior-Ingenieure. McGoffin stellte fest, dass ein konversationsorientierter Stil, die Erklärung von Annahmen und die Nutzung von Planungsmodi weitaus effektiver waren als knappe Befehle. Zum Beispiel, als es darum ging, robuste Regressionstests hinzuzufügen, initiierte ein Prompt wie /plan Ich habe kürzlich beobachtet, wie Copilot Tests fröhlich aktualisiert, um seinen neuen Paradigmen zu entsprechen, obwohl diese Tests nicht aktualisiert werden sollten. Wie kann ich einen reservierten Testbereich erstellen, den Copilot nicht berühren darf oder reservieren muss, um sich vor Regressionen zu schützen? einen produktiven Dialog. Dieses Hin und Her, oft mit dem leistungsstarken Modell claude-opus-4-6, führte zu ausgeklügelten Lösungen wie Vertragstests-Leitplanken, die nur menschliche Ingenieure aktualisieren konnten, um sicherzustellen, dass kritische Funktionalität geschützt blieb.

Architektonische Strategien: Die Grundlage KI-gestützter Qualität

Für menschliche Ingenieure werden die Pflege einer sauberen Codebasis, das Schreiben von Tests und die Dokumentation von Features unter Feature-Druck oft nachrangig behandelt. In der agentengesteuerten Entwicklung werden diese jedoch von größter Bedeutung. McGoffin entdeckte, dass das Investieren von Zeit in Refactoring, Dokumentation und das Hinzufügen von Testfällen die Fähigkeit von Copilot, sich in der Codebasis zurechtzufinden und dazu beizutragen, dramatisch verbesserte. Ein agenten-erstes Repository lebt von Klarheit. Dies ermöglicht es Entwicklern sogar, Copilot mit Fragen wie 'Angesichts meines jetzigen Wissens, wie würde ich das anders gestalten?' zu versehen, wodurch theoretische Refactorings mit KI-Unterstützung zu realisierbaren Projekten werden. Dieser kontinuierliche Fokus auf die architektonische Gesundheit stellt sicher, dass neue Features trivial geliefert werden können.

Iterationsstrategien: Dem Prozess vertrauen, nicht nur dem Agenten

Die Entwicklung von KI-Modellen hat die Denkweise von "Vertrauen, aber überprüfen" zu einer vertrauensvolleren Haltung verschoben, ähnlich wie effektive Teams mit einer "den Prozess verantwortlich machen, nicht die Menschen"-Philosophie arbeiten. Diese "fehlerverzeihende Kultur" in der agentengesteuerten Entwicklung bedeutet, dass, wenn ein KI-Agent einen Fehler macht, die Reaktion darin besteht, die zugrunde liegenden Prozesse und Leitplanken zu verbessern, anstatt den Agenten selbst zu beschuldigen. Dies beinhaltet die Implementierung strenger CI/CD-Praktiken: strikte Typisierung zur Sicherstellung der Schnittstellenkonformität, robuste Linter für Codequalität und umfangreiche Integrations-, End-to-End- und Vertragstests. Während der manuelle Aufbau dieser Tests kostspielig sein kann, macht die Unterstützung durch Agenten ihre Implementierung viel günstiger, was ein kritisches Vertrauen in neue Änderungen schafft. Durch die Einrichtung dieser Systeme befähigen Entwickler Copilot, seine eigene Arbeit zu überprüfen, was widerspiegelt, wie ein Junior-Ingenieur auf Erfolg vorbereitet wird.

Den agentengesteuerten Entwicklungszyklus meistern

Die Integration dieser Prinzipien in einen praktischen Workflow schafft einen leistungsstarken, beschleunigten Entwicklungszyklus:

  1. Mit Copilot planen: Initiiere neue Features mithilfe von /plan. Iteriere über den Plan und stelle sicher, dass Tests und Dokumentationsaktualisierungen vor der Codeimplementierung enthalten und abgeschlossen sind. Die Dokumentation kann als zusätzlicher Satz von Richtlinien für den Agenten dienen.
  2. Mit Autopilot implementieren: Erlaube Copilot, das Feature mithilfe von /autopilot zu implementieren, indem seine Codegenerierungsfähigkeiten genutzt werden.
  3. Mit Copilot Code Review überprüfen: Fordere Copilot auf, einen Überprüfungszyklus zu initiieren. Dies beinhaltet das Anfordern des Copilot Code Review Agenten, das Bearbeiten seiner Kommentare und das erneute Anfordern von Überprüfungen, bis die Probleme gelöst sind.
  4. Menschliche Überprüfung: Führe eine abschließende menschliche Überprüfung durch, um sicherzustellen, dass Muster eingehalten werden und komplexe Entscheidungen mit der strategischen Absicht übereinstimmen.

Jenseits des Feature-Zyklus ist kontinuierliche Optimierung entscheidend. McGoffin fordert Copilot routinemäßig mit Befehlen wie /plan Überprüfe den Code auf fehlende Tests, möglicherweise fehlerhafte Tests und toten Code oder /plan Überprüfe die Dokumentation und den Code, um Dokumentationslücken zu identifizieren. Diese Überprüfungen, die wöchentlich oder bei der Integration neuer Features durchgeführt werden, stellen sicher, dass die agentengesteuerte Entwicklungsumgebung gesund und effizient bleibt.

Die Zukunft der Softwareentwicklung mit KI

Was als persönliche Suche begann, eine frustrierende Analyseaufgabe zu automatisieren, hat sich zu einem neuen Paradigma für die Softwareentwicklung entwickelt. Agentengesteuerte Entwicklung, angetrieben durch Tools wie GitHub Copilot und fortschrittliche Modelle wie Claude Opus, geht nicht nur darum, Entwickler schneller zu machen; es geht darum, die Art der Arbeit für KI-Forscher und Softwareingenieure grundlegend zu verändern. Durch die Auslagerung intellektueller Mühsal an intelligente Agenten können Teams ein beispielloses Maß an Produktivität, Zusammenarbeit und Innovation erreichen und sich letztendlich auf die kreativen und strategischen Herausforderungen konzentrieren, die den Fortschritt wirklich vorantreiben. Dieser Ansatz kündigt eine aufregende Zukunft an, in der KI-Agenten nicht nur Werkzeuge, sondern integrale Mitglieder des Entwicklungsteams sind und die Art und Weise, wie wir Software erstellen und warten, transformieren.

Häufig gestellte Fragen

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.

Bleiben Sie informiert

Erhalten Sie die neuesten KI-Nachrichten per E-Mail.

Teilen