Intelligentere Code-Reviews mit GitHub Copilot: Tipps und Best Practices

Warum KI-gestützte Code-Reviews heute wichtig sind

Die rasanten Fortschritte im Bereich der Künstlichen Intelligenz (KI) haben den Markt in den letzten Jahren im Sturm erobert, insbesondere die Programmierbranche, die am stärksten davon betroffen war. Entwickler sind nicht nur offener für technologische Innovationen, sondern KI hat sich auch in Programmiersitzungen als zuverlässig erwiesen, beispielsweise beim Verständnis komplexer Codelogik und Designmuster. Sie ist daher zu einem festen Bestandteil der Branche geworden, und es gibt kein Zurück mehr: Diese Tools sind einfach zu gut und zu wertvoll, um sie zu ignorieren. Entwickler, die sich weigern, werden den Anschluss verlieren, und einer der wichtigsten Prozesse, in denen KI nützlich sein kann, ist die Automatisierung von Code-Reviews.

Der Einsatz von KI-Tools für automatisierte Code-Reviews bietet zahlreiche Vorteile für Ihren Entwicklungsprozess und macht ihn schneller und zuverlässiger. KI kann viele Probleme vorhersehen, die durch fehlerhaften Code entstehen können, wie z. B. Performance-Probleme, versteckte Bugs, Code-Smells, technische Schulden und mehr. Sie ist somit eine sehr wertvolle und in der Regel notwendige dritte Meinung zu einem Pull Request, zusätzlich zur Meinung des Entwicklers und des Reviewers, wodurch der Review schneller, gründlicher und detaillierter wird. All dies wird die Codequalität Ihrer Projekte verbessern und Ihre Codebasis zuverlässig und optimiert halten.

In diesem Kontext zählt GitHub Copilot zu den besten KI-Tools für Softwareentwickler, da es sich nahtlos in VSCode integrieren und in Ihre GitHub CI/CD-Pipeline einbinden lässt. Es kann Pull Requests nach deren Erstellung automatisch überprüfen und Optimierungen vorschlagen. Dadurch wird das Risiko menschlicher Fehler minimiert und Ihre Services werden mit modernen Entwicklungstechnologien optimal unterstützt.

Wie man GitHub Copilot für Code-Reviews nutzt

Eine der wichtigsten Funktionen von GitHub Copilot für Sie und Ihr Unternehmen ist die unterstützte Code-Review. Sie fungiert als Assistent und hilft Reviewern, versteckte Fehler und Code-Smells aufzuspüren. Copilot kann beispielsweise komplexe Zusammenhänge erkennen, die in bestimmten Grenzfällen zu Problemen führen können, und fehlende Logik aufspüren. Kurz gesagt: Es ist ein sehr geschätzter Assistent für die Code-Review.

Um Copilot zu nutzen, müssen Sie sich zunächst mit Ihrem GitHub-Konto in der nativen VSCode-Erweiterung anmelden. So erhalten Sie Zugriff auf die kostenlose Version oder können sich direkt für ein Abonnement entscheiden. Falls Sie noch nicht viel Erfahrung mit KI haben, sollten Sie den Workflow unbedingt testen, bevor Sie sich für ein kostenpflichtiges Abonnement entscheiden. Nicht jeder wird sich sofort an dieses Tool gewöhnen, daher lohnt sich ein vorheriger Test. Die kostenlose Version und die kostenlose Testphase sind sehr großzügig und ermöglichen es Entwicklern, alle kostenpflichtigen Funktionen ein bis zwei Wochen lang zu nutzen. Das ist mehr als genug Zeit, um zu lernen, wie man Pull Requests mit Copilot überprüft.

Jetzt können wir uns der Verwendung unseres KI-Code-Review-Tools widmen. Wir werden es im nächsten Abschnitt ausführlich behandeln, aber hier eine kurze Einführung: Zunächst müssen Sie Ihrem Agenten den Codekontext bereitstellen und ihm erklären, welchen Teil er prüfen und verstehen soll. Anschließend müssen Sie ihm erklären, was er tut oder zumindest tun soll (also den Zweck des Codes und wie er funktionieren soll), eine Eingabeaufforderung festlegen und ihn bitten, Ihren Code zu überprüfen. Nun wollen wir genauer betrachten, wie wir ihn optimal gestalten können, damit Sie das volle Potenzial Ihres KI-Programmierassistenten ausschöpfen können.

Ein praktischer GitHub Copilot Code Review Workflow

Hier nun eine kurze Anleitung zur Verwendung von GitHub Copilot für Code-Reviews, um eine leistungsfähige und fehlerfreie Anwendung zu gewährleisten.

Schritt 1: Analysiere den Kontext der Pull-Anfrage

Um Ihre Copilot-Codeüberprüfung zu starten, müssen Sie zunächst einen klaren und prägnanten Kontext bereitstellen, der beschreibt, was der Chatbot verstehen, verarbeiten und analysieren soll. Verknüpfen Sie dazu Ihre Codeänderungen mit dem Chatbot, damit dieser weiß, welche Zeilen er analysieren soll. In VSCode können Sie dies üblicherweise mit der Tastenkombination <Strg + i> oder <Cmd + i> tun oder im Chat ein @-Zeichen verwenden, um Dateien zu verlinken. Anschließend können Sie eine Zusammenfassung der Änderungen anfordern, die Ihnen schnell einen Überblick über die Änderungen, ihren Zweck und ihre Funktion gibt.

Hier ist ein Beispiel für eine Aufgabenstellung für diesen Teil:

Sie führen eine KI-gestützte Codeüberprüfung durch.

Aufgabe 1:

• Geben Sie eine klare und prägnante Zusammenfassung der Änderungen.
• Erläutern Sie den Zweck der Änderungen.
• Geben Sie an, welche Systemteile betroffen sind (Module, Schichten, Abhängigkeiten).
• Heben Sie alle Architektur- oder Designänderungen hervor.
• Gehen Sie auf mögliche Auswirkungen auf Leistung, Sicherheit oder Wartbarkeit ein.

Schlagen Sie noch keine Lösungen vor. Fassen Sie lediglich den Umfang der Änderungen zusammen und analysieren Sie ihn.

Pull Request Diff:
——————-
[DIFF HIER EINFÜGEN]
——————-

Schritt 2: Risikobewertung anfordern

Nun folgt der zweite Schritt, bei dem wir KI zur Fehlersuche einsetzen. In diesem wichtigen Schritt lernen wir mögliche Risiken kennen und verhindern, dass versteckte Fehler oder Leistungsprobleme in die Produktion gelangen. Dies ist wahrscheinlich der wichtigste Schritt, da hier die eigentliche Codeüberprüfung stattfindet. Sie müssen genau verstehen, was hinzugefügt wurde, wie der neue Code funktioniert und was er leisten soll bzw. nicht leisten soll. Einer der größten Vorteile KI-gestützter Softwareentwicklung ist, dass sie die Qualität Ihrer Codebasis hoch hält und versteckte Fehler findet, bevor diese Probleme verursachen.

Dies ist ein Beispiel für einen gut strukturierten Aufgabenstellungsschritt, der Ihnen dabei helfen kann. Wenn Sie nicht genau wissen, was Ihr Assistent tun soll, können Sie ChatGPT bitten, Ihnen bei der Formulierung eines Aufgabenstellungsschritts zu helfen.

Betrachten Sie nun denselben Pull Request aus technischer Sicht im Detail.

Aufgabe 2: 1. Finden Sie mögliche Fehler (Logikfehler, NullReferenceException, Race Conditions und Grenzfälle).

• Finden Sie Sicherheitslücken (Risiken von Code-Injection, fehlerhafte Validierung und unsichere Datenverarbeitung).
• Untersuchen Sie Performance-Probleme wie unnötige Schleifen, blockierende Operationen und ineffiziente Abfragen.
• Prüfen Sie Probleme mit der Codequalität, z. B. SOLID-Verletzungen, Duplikation, unpassende Namensgebung und starke Kopplung.
• Schlagen Sie gegebenenfalls korrigierte Codeabschnitte vor.
• Erläutern Sie, warum jedes Problem ein Problem darstellt.

Beschreiben Sie Ihre Vorgehensweise klar und geben Sie Anweisungen. Fügen Sie bei Bedarf aussagekräftigere Codebeispiele hinzu.

Pull Request Diff:
——————-
[DIFF HIER EINFÜGEN]
——————-

Schritt 3: Vorschläge für ein besseres Refactoring machen

Im letzten Schritt bitten wir Copilot um Refactoring-Vorschläge und andere Möglichkeiten zur Codeverbesserung, wobei Performance, Designmuster und die Erkennung von Verstößen gegen Projektmuster berücksichtigt werden. Manche mögen argumentieren, dieser Schritt sei überflüssig, da die meisten Punkte bereits in den vorherigen Schritten behandelt worden sein sollten, doch Vorsicht ist besser als Nachsicht.

Sie befinden sich im dritten Schritt einer KI-gestützten Codeüberprüfung im GitHub Copilot-Workflow.

Der untenstehende Pull Request-Diff wurde bereits zusammengefasst und auf Fehler geprüft.

Aufgabe: Schlagen Sie Möglichkeiten zur Verbesserung des Refactorings gemäß den SOLID-Prinzipien vor.

Insbesondere:

1. Verstöße gegen folgende Bestimmungen feststellen

– Das Prinzip der Einzelverantwortung (Single Responsibility Principle, SRP)

– Das Prinzip von Offenheit und Geschlossenheit (Open and Closed Principle, OCP)

– Das Liskovsche Substitutionsprinzip (Liskov Substitution Principle, LSP) – Das Prinzip der Schnittstellentrennung (Interface Segregation Principle, ISP)

– Das Abhängigkeitsumkehrprinzip (DIP)

2. Heben Sie eng gekoppelte Komponenten oder Bereiche mit geringer Kohäsion hervor.
   3. Schlagen Sie strukturelle Verbesserungen vor, um Wartbarkeit und Erweiterbarkeit zu optimieren.
   4. Empfehlen Sie gegebenenfalls Entwurfsmuster (Strategie, Factory, Adapter usw.).
   5. Stellen Sie gegebenenfalls verbesserte Codebeispiele bereit.
   6. Erläutern, warum jede Refaktorisierung die langfristige Skalierbarkeit und Codequalität verbessert.

Konzentrieren Sie sich auf pragmatische Verbesserungen, die für Produktionsumgebungen geeignet sind. Vermeiden Sie unnötige Komplexität.

Pull Request Diff:
——————-
[DIFF HIER EINFÜGEN]
——————-

Praxisbeispiel: Einsatz von Copilot für KI-gestützte Code-Überprüfung

Hier ist ein konkretes Codebeispiel, das zeigt, wie man GitHub Copilot für KI-gestützte Code-Reviews und in diesem Fall auch für Refactoring einsetzt. Zuerst analysieren wir einen Code, der nicht besonders lesbar oder gut strukturiert ist: Er funktioniert zwar, kann aber hinsichtlich Skalierbarkeit, Vermeidung zukünftiger Fehler und Entfernung von „magischen“ Zahlen verbessert werden. Anschließend führen wir ihn über eine Eingabeaufforderung in Copilot aus und analysieren den resultierenden Code. Die Reihenfolge ist wie folgt:

Problematischer Code:

export function calculateDiscount(price: number, userType: string) {

   if (userType === "premium") {

       return price * 0.8;

   } else if (userType === "vip") {

       return price * 0.7;

   } else {

       return price;

   }

}

Verwendeter Prompt:

Überprüfe diese Funktion und schlage Verbesserungen hinsichtlich Skalierbarkeit und Wartbarkeit vor.

Erwartete Antwort:

• Vorschlag zur Erstellung eines Enums
  Map-Strategie
  Bessere Typisierung
  Mögliche Validierung

Refaktorierter Code:

enum UserType {

   Premium = "premium",

   VIP = "vip",

   Standard = "standard"

}

const discountMap: Record<UserType, number> = {

   [UserType.Premium]: 0.2,

   [UserType.VIP]: 0.3,

   [UserType.Standard]: 0

};

export function calculateDiscount(price: number, userType: UserType): number {

   return price * (1 - discountMap[userType]);

}

Obwohl der Code auf den ersten Blick etwas verwirrender wirkt, da er nicht mehr so ​​übersichtlich ist wie zuvor, verwendet er ein Mapping-Muster, Enums, klar definierte Typen und ist insgesamt deutlich skalierbarer und zukunftssicherer. Zudem lassen sich die erstellten Typen in anderen Teilen der Codebasis wiederverwenden, was die Integrität, die Wiederverwendbarkeit des Codes und die Anwendung sauberer Codemuster gewährleistet.

Häufige Fallstricke bei KI-gestützten Code-Reviews

Auch wenn Tools wie Copilot sehr leistungsstark für die Optimierung von Programmier-Workflows sind und hervorragende Partner beim Pair Programming darstellen, lauern dennoch einige Fallstricke, in die man tappen kann. Solche Fehler können katastrophale Folgen haben. Daher möchten wir Sie auf die häufigsten Schwachstellen von KI hinweisen und auf die Fehler, die sie üblicherweise macht (und wahrscheinlich auch in Zukunft machen wird). Einige dieser Fehler sind jedoch rein menschlich bedingt, auch wenn sie durch KI verursacht werden. Das ist umso gefährlicher: Keine KI kann menschliche Fehler verhindern, daher sollten sich Anwender der Gefahren bewusst sein.

Übermäßige Abhängigkeit

Das passiert, wenn man sich zu sehr auf seinen KI-Programmierassistenten verlässt. Man muss alles, was automatisch generiert wird, immer gründlich überprüfen und testen: Die Systeme irren sich oft und liefern manchmal sehr selbstsicher Code, der einfach nicht funktioniert. Deshalb sollte man niemals blind vertrauen und das Ergebnis immer selbst überprüfen.

Falsch positive Ergebnisse

Ein KI-Agent begeht sehr häufig gravierende Fehler mit absoluter Überzeugung. Er gibt seine Fehler nicht oder nur sehr selten zu, und das ist sehr irreführend. Wir neigen dazu, dem Chatbot zu glauben, da wir seine Trainingsdaten und seine vermeintliche Treffsicherheit und Selbstsicherheit mehr oder weniger respektieren und ihm letztendlich zu sehr vertrauen.

All dies führt uns zu dem Schluss, dass KI-gestützte Programmierung das menschliche Auge und einen menschlichen Bediener niemals vollständig ersetzen kann. Letztendlich hängt alles davon ab, dass Menschen Code, Produktkonzepte, Architektur, Designmuster usw. tatsächlich verstehen. Sie müssen immer verstehen, wie Ihr System vernetzt ist, was Ihr Code tun sollte und was nicht, und schließlich wissen, wie Sie Ihren KI-Agenten zum besten Ergebnis führen.

Fazit: Intelligentere Code-Review-Prozesse mit KI entwickeln

Zusammenfassend lässt sich sagen, dass die Übernahme von Entwicklungsprozessen durch KI keine Modeerscheinung oder ein vorübergehender Trend ist. Sie ist gekommen, um zu bleiben und hat die gesamte Branche bereits revolutioniert. KI-Tools für die Softwareentwicklung werden immer leistungsfähiger und können menschliche Entwickler mitunter deutlich übertreffen. Daher ist es stets eine wertvolle Ergänzung, sie im Team einzusetzen oder, wie der Name schon sagt, als Copilot zu nutzen.

Vor diesem Hintergrund wird verständlich, warum Unternehmen, die KI-gestütztes Codieren und KI-gestützte Softwareentwicklung einsetzen, so erfolgreich sind. Die Entwicklung wird dadurch deutlich schneller, sicherer und zuverlässiger, da KI-Assistenten schnell spezialisierter und vertrauenswürdiger werden und sich in kürzester Zeit zu einem festen Bestandteil der Branche entwickelt haben. Wenn Sie also als Entwickler herausstechen oder als Unternehmen mit den modernen Trends Schritt halten möchten, sollten Sie es unbedingt ausprobieren und sehen, wie viel schneller Sie liefern und wie viel besser Ihr Code werden kann.