Vibe Coding mit dem GitHub Copilot Agent

Rückblick: Was ist "Vibe Coding"?

In meinen letzten Artikeln über JetBrains Junie und Google Jules habe ich das Konzept des "Vibe Coding" vorgestellt. Es beschreibt diesen fast magischen Zustand der höchsten Produktivität und Kreativität, den Entwickler als "Flow" kennen. Dieser Zustand wird jedoch allzu oft von dem unterbrochen, was ich "Vibe-Killer" nenne: repetitive Aufgaben, langwieriges Debugging, das Warten auf CI-Pipelines oder die mühsame Einarbeitung in fremde Codebasen.

Die neuen KI-gestützten Coding-Assistenten oder "Agenten" versprechen, genau diese "Vibe-Killer" zu eliminieren und uns Entwicklern zu ermöglichen, länger im kreativen Fluss zu bleiben. Sie agieren nicht mehr nur als passive Werkzeuge, die Code vervollständigen, sondern als aktive, (teil-)autonome Partner im Entwicklungsprozess.

Was ist der GitHub Copilot Agent überhaupt?

Mehr als nur Autocomplete: Die Transformation von Copilot

GitHub Copilot hat die Art, wie wir Code schreiben, bereits nachhaltig verändert. Doch der Copilot Agent, oft im Kontext von Copilot Workspace oder als erweiterte Funktionalität in VS Code erwähnt, ist eine fundamentale Weiterentwicklung. Er geht über die bloße Vorhersage der nächsten Codezeile hinaus und agiert als ein echter, dialogbasierter Agent, der komplexe, mehrstufige Aufgaben planen und ausführen kann.

Im Gegensatz zu Jules, der in einer externen Umgebung arbeitet, ist der Copilot Agent direkt in die Chat- und Terminal-Funktionen von VS Code integriert. Er kann auf das Dateisystem zugreifen, Terminal-Befehle ausführen und den Kontext des gesamten Arbeitsbereichs verstehen.

Der Agent im Detail: Wie funktioniert er?

Der Kern des Copilot Agenten ist ein multimodales Sprachmodell, das von GitHub/Microsoft trainiert wurde. Der Prozess beginnt, ähnlich wie bei Junie, mit einem Prompt des Entwicklers im Chat-Fenster von VS Code.

1. Planung (Reasoning): Der Agent analysiert die Aufgabe und zerlegt sie in einen logischen Plan aus Einzelschritten. Dieser Plan kann das Lesen von Dateien, das Schreiben von neuem Code, das Modifizieren bestehender Dateien oder das Ausführen von Terminal-Befehlen umfassen.
2. Ausführung: Der Agent arbeitet diesen Plan Schritt für Schritt ab. Ein entscheidendes Merkmal ist hierbei die Interaktivität. Bevor potenziell destruktive Aktionen (wie das Ausführen eines Tests oder das Ändern einer Datei) durchgeführt werden, bittet der Agent oft um Bestätigung.
3. Iteration und Korrektur: Wie ein menschlicher Entwickler kann auch der Agent auf Fehler stoßen. Wenn ein Test fehlschlägt oder ein Befehl einen Fehler zurückgibt, versucht er autonom, das Problem zu analysieren und zu korrigieren. [cite_start]Diese iterative Arbeitsweise ist ein deutlicher Fortschritt gegenüber einfachen Code-Generatoren.
4. Abschluss: Sobald alle Schritte erfolgreich ausgeführt wurden, präsentiert der Agent das Ergebnis. Der Entwickler hat die volle Kontrolle, kann die Änderungen überprüfen, sie verwerfen oder weitere Anweisungen geben.

Fine-Tuning - Eigene Vorgaben

Aufgaben kann man oft auf verschiedene Weisen ausführen. Manches, wie der Code-Style, sind geschacksache oder durch Projekt-Vorgaben definiert.

Wo der Agent seine Test ablegt oder man bestimmte Dateien ablegen soll oder in welchen Format eine Dokumentation erstellt werden soll, kann man dem Agenten über eine Datei .github/copilot-instructions.md mitgeben.

In diesem Markdown-Dokument beschreibt man einfach, was einem wichtig ist. Das Dokument dient dann als System-Prompt für den Agenten.

Integration in die Entwicklungsumgebungen

VS Code

Die nahtlose Integration in VS Code ist die größte Stärke des Copilot Agenten. Es ist kein separates Tool, keine externe Webseite. Man bleibt in der gewohnten Umgebung. Über spezielle Befehle im Chat (z.B. @workspace oder @terminal) kann man den Agenten direkt auf den Code oder die Kommandozeile ansetzen.

Diese tiefe Integration ermöglicht es dem Agenten, den gesamten Kontext zu erfassen: offene Dateien, die Projektstruktur, Abhängigkeiten und sogar den Inhalt des Terminals. Dies ist ein entscheidender Vorteil, da der "Vibe" nicht durch einen ständigen Wechsel zwischen verschiedenen Tools und Fenstern gebrochen wird.

Integration in Jetbrains IDEs

In Jetbrains IDEs lässt sich der CoPilot über den internen Plugin Marktplatz einfach installieren.

Da der Agent (Stand: 08.06.2025) noch als Preview-Version markiert ist, muss in der GitHub Organisation die Installation von Preview-Versionen aktiviert sein. Ist das nicht der Fall, fehlt der Tab "Agent Preview" in der IDE.

Was geht (schon)?

Theorie ist gut, aber wie schlägt sich der Agent bei realen Aufgaben? Ich habe ihn, ähnlich wie Junie und Jules, auf einige typische "Vibe-Killer"-Szenarien losgelassen.

Anwendungsfall 1: Modernisierung einer Legacy-Codebase

Ähnlich wie bei der Migration des Wormatia Livetickers von Vue 2 auf Vue 3 mit Junie, kann man dem Copilot Agenten eine vergleichbare Aufgabe geben.

• Prompt: "Analysiere diesen Vue 2 Komponenten-Code, identifiziere die veralteten Muster und migriere ihn nach Vue 3 unter Verwendung der Composition API. Aktualisiere außerdem die package.json, um die notwendigen npm-Pakete zu installieren."

Der Agent beginnt mit einer Analyse der Komponente, schlägt einen Plan vor (z.B. "1. package.json aktualisieren, 2. npm install ausführen, 3. Vue-Komponente umschreiben"), und führt diesen nach Bestätigung aus. Er erkennt, dass v-model in Vue 3 anders funktioniert, ersetzt Filter durch computed Properties und strukturiert den Code entsprechend der Composition API. Das Ergebnis ist eine funktionale, modernisierte Komponente, die manuell einen erheblichen Zeitaufwand bedeutet hätte.

Anwendungsfall 2: Automatisierte Fehlerbehebung und Debugging

Dies ist eine der beeindruckendsten Fähigkeiten. Man kann dem Agenten den Output eines fehlgeschlagenen Tests oder eine Fehlermeldung aus der Konsole geben.

• Prompt: "Der folgende Test schlägt mit dieser Fehlermeldung fehl: [Fehlermeldung hier einfügen]. Finde die Ursache im Code und behebe sie."

Der Copilot Agent analysiert den Stack Trace, navigiert zur fehlerhaften Code-Stelle, versteht die Logik (oder deren Fehler) und schlägt eine Korrektur vor. Er kann sogar selbstständig die Tests erneut ausführen, um seine Lösung zu verifizieren. Diese Fähigkeit, autonom Fehler zu korrigieren, erinnert stark an die iterative Arbeitsweise, die ich bei Junie beobachtet habe, wo dieser ebenfalls Tests ausführt und Fehler korrigiert, bis die Implementierung den Anforderungen entspricht.

Anwendungsfall 3: Generierung von Dokumentation und Tests

Eine klassische Fleißaufgabe, die perfekt für einen Agenten geeignet ist. Hier zeigt sich die Stärke des Kontexts.

• Prompt: "Erstelle eine README.md-Dokumentation für das aktuelle Projekt. Analysiere die Kommandos in n98-magerun2 und dokumentiere deren Optionen und Argumente. Schreibe außerdem Unit-Tests für die CreateDiPreferenceCommand-Klasse."

[cite_start]Dieses Szenario ähnelt meinem Test mit Google Jules und n98-magerun2. Der Copilot Agent kann, genau wie Jules, die Kommandozeilen-Tools analysieren, deren Hilfe-Ausgaben parsen, und daraus eine strukturierte Dokumentation erstellen. Gleichzeitig kann er den Quellcode der CreateDiPreferenceCommand-Klasse analysieren und passende Unit-Tests mit einem Mocking-Framework wie PHPUnit generieren.

Anwendungsfall 4: Komplexe Refactorings und Optimierungen

Hier geht der Agent über einfache Aufgaben hinaus. Man kann ihm ganze Klassen oder Module zur Überarbeitung geben.

• Prompt: "Refaktoriere diese Klasse, um sie an die SOLID-Prinzipien anzupassen. Extrahiere die Datenbanklogik in ein separates Repository und verwende Dependency Injection, um die Abhängigkeiten aufzulösen."

Der Agent versteht die abstrakten Konzepte von Softwarearchitektur und wendet sie auf den konkreten Code an. Er erstellt neue Dateien, verschiebt Code, passt die Konstruktoren an und sorgt dafür, dass der Code am Ende sauberer und wartbarer ist. Dies ist eine Aufgabe, die über das Niveau eines Junior-Entwicklers hinausgeht und zeigt das enorme Potenzial dieser Technologie.

Was geht (noch) nicht?

Trotz der beeindruckenden Fortschritte ist der GitHub Copilot Agent kein Allheilmittel. Es gibt klare Grenzen, die den menschlichen Entwickler weiterhin unverzichtbar machen.

Komplexe Architekturentscheidungen

Der Agent ist (noch) nicht in der Lage, tiefgreifende architektonische Entscheidungen für ein gesamtes Projekt zu treffen. ragen wie "Sollten wir für dieses Projekt eine Microservice-Architektur oder einen Monolithen verwenden?" oder "Welches Datenbank-System ist für unsere Skalierungsanforderungen am besten geeignet?" erfordern menschliches Fachwissen, Erfahrung und ein tiefes Verständnis der Geschäftsziele.

Feinheiten und Projekt-spezifischer Kontext

Einem KI-Modell fehlt oft das "Gefühl" für den Kontext eines Projekts, das sich über Jahre entwickelt hat. Warum wurde eine bestimmte technische Schuld bewusst in Kauf genommen? Welches obskure Legacy-System muss aus historischen Gründen weiterhin unterstützt werden? Diese Nuancen, die oft nicht explizit dokumentiert sind, kann der Agent nur schwer erfassen. Eine menschliche Überprüfung der generierten Änderungen ist daher unerlässlich.

Interaktion und iterative Kommunikation

Die Kommunikation ist noch nicht so flüssig wie mit einem menschlichen Kollegen. Obwohl der Agent auf Feedback reagiert, ist der Dialog manchmal noch hölzern. Man kann nicht einfach sagen "Mach das nochmal, aber diesmal ein bisschen eleganter." Man muss seine Anweisungen sehr präzise formulieren.

Der heilige Gral der Interoperabilität

MCP

In meinem Artikel über das Model Context Protocol (MCP) habe ich erläutert, warum ein offener Standard für die Kommunikation zwischen KI-Modellen und externen Tools so wichtig ist. MCP-Support ist in GitHub CoPilot schon integriert. Über "Tools" kann man eigene MCP Server hinterlegen die dann richtige Automationen im eigenen LAN ausführen können. Damit lassen sich nicht nur interne Prozesse integrieren sondern auch privates Wissen in den Agenten einbunden. Es ist damit möglich dem Agenten Daten aus internen Datenbanken bereitzustellen. Diese Daten werden allerdings auch von dem genutzten LLM weiterverarbeitet. Daher ist das Vorgehen auf die eigenen Vorgaben im Unternehmen zu prüfen.

Die MCP Server werden über eine Datei mcp.json definiert. Die IDE öffnet die Datei, sobald man auf das "Tools" Symbol klickt und angibt, dass man ein Tool hinzufügen will.

Hier ein Beispiel aus der GitHub Doku für eine solche JSON Datei:

{
  "servers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Der MCP-Server kann aber auch via HTTP als Remote-Server angesprochen werden.
In meinen Tests arbeitete die Integration sehr stabil.

Copilots aktueller Ansatz: Ein geschlossenes System?

Derzeit kommuniziert GitHub Copilot standardmäßig mit den Servern von GitHub. Es ist tief in deren Ökosystem integriert. Es ist zwar möglich, die Erweiterung so zu konfigurieren, dass sie stattdessen Tools aus eigenen MCP-Servern nutzt, aber dies ist nicht der Standardweg und erfordert zusätzliche Konfiguration. Der Fokus liegt klar auf der nahtlosen Erfahrung innerhalb des Microsoft/GitHub-Universums.

Fazit und Ausblick: Programmierer oder Dirigent?

Der GitHub Copilot Agent ist mehr als nur ein weiteres Werkzeug; er ist ein Paradigmenwechsel. Er ist ein unglaublich mächtiger Assistent, der das Potenzial hat, die "Vibe-Killer" in unserem Alltag effektiv zu bekämpfen und unsere Produktivität und Kreativität auf ein neues Level zu heben. Die Fähigkeit, komplexe Aufgaben zu planen, iterativ auszuführen und aus Fehlern zu lernen, hebt ihn deutlich von früheren Generationen der Code-Vervollständigung ab.

Die Rolle des Entwicklers wandelt sich unaufhaltsam. Wir werden weniger zu reinen Codern und mehr zu Architekten, Dirigenten und Agent-Handlern. Unsere Hauptaufgabe wird darin bestehen, komplexe Probleme in präzise Anweisungen für KI-Agenten zu zerlegen, deren Ergebnisse zu validieren und die übergeordneten architektonischen Entscheidungen zu treffen.

Es wird auch immer mehr der Begriff Task Driven Development genutzt. Das trifft es ganz gut. Je genauer eine Aufgabe beschrieben wird, desto besser ist auch das Ergebnis. Hier profitieren wieder die erfahrenen Entwickler.

Insgesamt hatte ich etwas schlechtere Ergebnisse mit GitHub CoPilot im Vergleich zu JetBrains Junie. Allerdings bin ich nicht, wie bei Junie, in Rate-Limits gelaufen. Es war höchstens mal der Context des LLM ausgereitzt und dann gab es eine passende Fehlermeldung.
Größere Aufgaben habe ich dann auf mehrere Sessions in GitHub CoPilot Agent aufgeteilt und konnte so auch meistens mein Ziel erreichen.