Verwenden von GitHub Copilot zur Verringerung der technischen Schulden

Einleitung

Technische Schulden werden in jeder Codebasis angesammelt: doppelter Code, fehlende Tests, veraltete Abhängigkeiten und inkonsistente Muster. Diese Probleme können sich ansammeln, da die Featureentwicklung in der Regel eine höhere Priorität erhält. In diesem Lernprogramm wird erläutert, wie Sie mit GitHub Copilot technische Schulden systematisch angehen können, ohne die Entwicklungsgeschwindigkeit einzuschränken.

Für wen dieses Lernprogramm gilt

Dieses Lernprogramm soll Entwicklungsteams und technische Leads dabei unterstützen, technische Schulden zu reduzieren und gleichzeitig das Tempo aufrechtzuerhalten, in dem neue Features bereitgestellt werden. Sie müssen über folgende Voraussetzungen verfügen:

Ein Copilot Abonnement mit Zugriff auf Copilot-Cloud-Agent
Administrator-access zu mindestens einem Repository
Vertrautheit mit dem Entwicklungsworkflow Ihres Teams

Umfang

Am Ende dieses Lernprogramms haben Sie folgendes gelernt:

Verwenden von Copilot zur Implementierung von sofortigen Korrekturen
Nutzung von Copilot-Cloud-Agent für umfangreiche Bereinigungsaufgaben
Erstellen von benutzerdefinierten Anweisungen zur Anpassung Copilot an die Standards Ihres Teams
Messen der Auswirkungen von Copilot auf Ihre technische Schuld

Grundlegendes zum Technischen Schuldenproblem

Bevor Sie mit der Verringerung der technischen Schulden in einer Codebasis beginnen, sollten Sie einige Zeit in Anspruch nehmen, um die Arten der technischen Schulden zu identifizieren, denen Ihr Team am häufigsten gegenübersteht.

Zu den allgemeinen Arten von technischen Schulden gehören:

        **Codeduplizierung** – Dieselbe Logik, die an mehreren Stellen implementiert wurde

        **Fehlende Tests** – Features ohne ausreichende Testabdeckung

        **Veraltete Abhängigkeiten** – Bibliotheken, die um mehrere Versionen hinter den aktuellen Versionen zurückliegen

        **Inkonsistente Muster** – Verschiedene Ansätze für dasselbe Problem in Ihrer Codebasis

        **Legacycode – Alter Code** , der funktioniert, aber nicht den aktuellen Standards entspricht

Die Kosten technischer Schulden summieren sich über die Zeit:

Senior Engineers verbringen Zeit mit Routineupdates anstelle des Architekturdesigns
Codeüberprüfungen werden länger, wenn Prüfer inkonsistente Muster diskutieren
Aufgrund verwirrender Codeorganisation dauert das Onboarding neuer Entwickler länger.
Das Bereitstellungsrisiko steigt, wenn veraltete Abhängigkeiten Schwachstellen ansammeln.

Verwenden Sie Copilot in Ihrer IDE für sofortige Korrekturen

Die beste Möglichkeit, technische Schulden in Ihrer Codebasis zu vermeiden, besteht darin, zu verhindern, dass sie an erster Stelle in die Codebasis gelangt.

Wenn während der Entwicklung technische Schulden auftreten, beheben Sie sie sofort mithilfe Copilot Ihrer IDE.

Workflow für schnelle Umgestaltung

Heben Sie während der Arbeit in Ihrer IDE Code hervor, der eine Verbesserung erfordert.
Öffnen Sie Copilot-Chat in der IDE.
Bitten Sie Copilot , den Code umzugestalten. Beispiel:
- Extract this into a reusable helper and add error handling
- Standardize this logging format to match our pattern
- Add null checks for all optional parameters
- Replace this deprecated API call with the current version
Überprüfen Sie die vorgeschlagenen Änderungen.
Akzeptieren Sie die Änderungen oder bitten Sie Copilot, seinen Ansatz zu ändern.
Führen Sie Ihre Tests aus, um zu überprüfen, ob die Änderungen ordnungsgemäß funktionieren.

Beispiel: Standardisieren der Fehlerbehandlung

Wenn Sie eine inkonsistente Fehlerbehandlung finden, z. B.:

// Highlight this code
try {
  await fetchData();
} catch (e) {
  console.log(e);
}

Bitten Sie Copilot , den Code zu verbessern, z. B.:

Copilot prompt

Refactor this to use structured logging and proper error handling

// Highlight this code
try {
  await fetchData();
} catch (e) {
  console.log(e);
}

Refactor this to use structured logging and proper error handling

Refactor this to use structured logging and proper error handling

          Copilot kann Folgendes vorschlagen:

try {
  await fetchData();
} catch (error) {
  logger.error('Failed to fetch data', {
    error: error.message,
    stack: error.stack,
    timestamp: new Date().toISOString()
  });
  throw error;
}

Hinweis

Diese Antwort ist ein Beispiel. Copilot-Chat Antworten sind nicht deterministisch, daher erhalten Sie möglicherweise eine andere Antwort, wenn Sie dieselbe Eingabeaufforderung für denselben Code ausführen.

Durch die Einführung des In-the-Moment-Fix-Ansatzes können Sie sicherstellen, dass Der Unterstandardcode nicht zu Ihrer Codebasis hinzugefügt wird, und Sie vermeiden die Erstellung eines Backlog-Problems, das möglicherweise nie behoben werden kann.

Weitere Informationen zur Verwendung Copilot in Ihrer IDE finden Sie unter GitHub Copilot Fragen in Ihrer IDE stellen.

Verwendung von Copilot-Cloud-Agent für die Refaktorisierung im großen Maßstab

Einige Umgestaltungsaufgaben sind nur zu groß, um sie abzuschließen, während jeder im Team beschäftigt ist, neue Features zu entwickeln. In dieser Situation können Sie Copilot-Cloud-Agent verwenden, um diese Aufgaben autonom zu verarbeiten. Menschlicher Einsatz wird weiterhin erforderlich sein – zumindest für die Überprüfung der Änderungen Copilot-Cloud-Agent. Wenn Copilot jedoch den Großteil der Arbeit übernimmt, können Sie große Umstrukturierungen mit erheblich weniger Auswirkungen auf die Produktivität Ihres Teams durchführen.

Empfohlene Verwendung von Copilot-Cloud-Agent

Verwende Copilot-Cloud-Agent für Aufgaben, die:

Berühren Sie viele Dateien in Ihrer Codebasis.
Systematische Änderungen erfordern (z. B. entfernen alte Featurekennzeichnungen)
Benötigen sorgfältige Tests, sind aber einfach zu implementieren.
Würde die Featureentwicklung unterbrechen, wenn dies manuell erfolgt ist

Beispiele sind:

Frameworkupgrades, die sich auf 50+ Dateien auswirken
Entfernen veralteter Featurekennzeichnungen
Migrieren zu strict TypeScript
Aktualisieren von Abhängigkeitsversionen
Standardisieren von Importmustern

Workflow für Copilot-Cloud-Agent

Erstellen Sie ein GitHub Problem, das die Umgestaltungsaufgabe beschreibt.

Achten Sie darauf, was geändert werden muss. Beispiel:

Remove all feature flags marked for cleanup in Q2.

These flags are:
- `enable_new_dashboard`
- `beta_export_feature`
- `experimental_search`

All three flags are enabled by default in production.

Remove the flag checks and keep the "enabled" code path.

Weisen Sie das Problem dem Copilot-Benutzer zu.
```
       Copilot-Cloud-Agent wird:
```
- Einrichten einer Entwicklungsumgebung
- Öffnen einer Entwurfs-Pullanforderung
- Nehmen Sie die erforderlichen Änderungen am Code vor
- Ausführen der Tests
- Finalisieren Sie den Pull-Request zur Überprüfung
- Die Überprüfung des Pull-Requests anfordern
Überprüfen Sie die Pull-Anforderung genauso wie eine Pull-Anforderung, die von einem Menschen erstellt wird.
Hinterlassen Sie Kommentare, wenn Änderungen erforderlich sind–Copilot-Cloud-Agent aktualisiert die Pull-Anforderung basierend auf Ihrem Feedback.
Durchlaufen Sie auf diese Weise, bis die Arbeit ordnungsgemäß abgeschlossen ist.
Genehmigen und Zusammenführen des Pull-Requests.

Weitere Informationen findest du unter Bitten GitHub Copilot, eine Pull-Anforderung zu erstellen und Überprüfen einer pull-Anforderung, die von GitHub Copilot erstellt wurde.

Sicherheitsschutzschienen

          Copilot-Cloud-Agent arbeitet mit integrierten Sicherheitsmaßnahmen:

Es kann nur an seine eigenen copilot/*-Verzweigungen gepusht werden
Es kann keine Pullanforderungen zusammenführen – erfordert Ihre Genehmigung
Alle Commits werden protokolliert und überwacht.
Ihre vorhandenen Branchenschutzrichtlinien bleiben aktiv
CI/CD-Prüfungen werden ausgeführt, bevor Code zusammengeführt wird

Erstellen von benutzerdefinierten Anweisungen für Ihr Team

Benutzerdefinierte Anweisungen helfen Copilot, die Codierungsstandards und Muster Ihres Teams zu verstehen. Dadurch wird sichergestellt, dass Vorschläge von Anfang an Ihren Erwartungen entsprechen.

Einrichten von benutzerdefinierten Anweisungen

Erstellen Sie in Ihrem Repository eine Datei mit dem Namen .github/copilot-instructions.md.
Fügen Sie die Codierungsstandards Ihres Teams in klaren, einfachen Anweisungen hinzu, z. B. mithilfe von Aufzählungen.
Übertragen Sie die Datei in Ihr Repository.

Beispiel für benutzerdefinierte Anweisungen

Hier ist ein Beispiel für effektive benutzerdefinierte Anweisungen:

## Our Standards

- Use structured logging, not console.log
- Sanitize user input before database queries
- Check for null/undefined on all optional parameters
- Keep functions under 50 lines (extract helpers if needed)
- Every public function needs a test
- Flag any loops that might trigger N+1 queries

## Error Handling

- Always use try-catch blocks for async operations
- Log errors with context (user ID, request ID, timestamp)
- Never swallow errors silently
- Return appropriate HTTP status codes

## Testing Requirements

- Unit tests for all business logic
- Integration tests for API endpoints
- Mock external services in tests
- Test both success and failure paths

Ausführliche Anleitungen zum Schreiben von benutzerdefinierten Anweisungen finden Sie unter Hinzufügen von benutzerdefinierten Repositoryanweisungen für GitHub Copilot.

Vorteile von benutzerdefinierten Anweisungen

Mit benutzerdefinierten Anweisungen an Ort und Stelle:

        Copilot macht Vorschläge für Code nach Ihren Mustern

Code-Reviews werden schneller, mit weniger Diskussionen über Stiländerungen
Neue Teammitglieder lernen Ihre Standards durch Copilot Vorschläge kennen
Die Konsistenz verbessert sich in Ihrer Codebasis.

Ausführen eines Pilotprogramms

Beginnen Sie klein, um die Auswirkungen ihrer technischen Schulden zu überprüfen Copilot, bevor Sie sie umfassend einführen.

Woche 1: Einrichten und Festlegen von Grundlagen

Stellen Sie sicher, dass alle Pilotteilnehmer Zugriff mit Copilot aktivierter Berechtigung habenCopilot-Cloud-Agent.
Zählen Sie die technischen Schuldenelemente in Ihrem Backlog:
- Anzahl der "technischen Schulden", "Routineaufgabe" oder ähnlich bezeichnete Probleme
- Anzahl veralteter Abhängigkeiten
- Anzahl der Dateien, die bei Linter-Prüfungen durchgefallen sind
Aktuelle Metriken nachverfolgen:
- Durchschnittliche Zeit für die Erstellung von Pullanforderungen zum Zusammenführen für die Umgestaltung von PRs
- Durchschnittliche Anzahl von Überprüfungsrunden pro Refactoring-PR
Erstellen Sie Ihre erste .github/copilot-instructions.md-Datei mit 3 bis 5 Ihrer wichtigsten Standards.

Wochen 2–4: Ausführen des Pilotprojekts

Wählen Sie 5 bis 10 Repositorys für Ihr Pilotprojekt aus.
Wählen Sie 1 bis 2 spezifische Probleme aus, die behoben werden sollen. Beispiel:
- Codeduplizierung in einem bestimmten Bereich
- Fehlende Tests für häufig geänderte Dateien
- Veraltete Abhängigkeiten
Verwenden Sie Copilot in Ihrer IDE für schnelle Korrekturen, wenn Probleme auftreten.
Weisen Sie größere Bereinigungsaufgaben zu Copilot-Cloud-Agent.
Überprüfen Sie alle Copilot generierten PRs sorgfältig.
Geben Sie Feedback zu Vorschlägen, um Ihre Vorlieben kennenzulernen Copilot .

Woche 5: Ergebnisse auswerten

Messen Sie nach dem Pilotprojekt Ihre Ergebnisse:

Wie viel schneller werden Refactoring-Pull-Requests zusammengeführt?
Wie viele Überprüfungsrunden benötigen sie jetzt?
Welche Arten von Codeänderungsvorschlägen, die von Copilot-Cloud-Agent in Pull-Requests gemacht wurden, akzeptierten Entwickler am häufigsten?
Welche Vorschläge brauchten die meisten Überarbeitungen?
Verbessern sich Ihre technischen Schuldenmetriken?
- Die Linter-Warnungen nehmen ab.
- Steigt die Testabdeckung?
- Sind die Abhängigkeitsversionen aktueller?

Aktualisieren Sie Ihre benutzerdefinierten Anweisungen basierend auf der Erkenntnis, welche Anleitung am meisten geholfen hat Copilot.

Messen des Erfolgs

Verfolgen Sie bestimmte Metriken, um die Auswirkungen Ihrer technischen Schuld zu verstehen Copilot.

Geschwindigkeitsmetriken

Überwachen Sie, wie Copilot die Entwicklungsgeschwindigkeit beeinflusst:

Zeit zum Schließen technischer Schuldenprobleme (Ziel: 30–50% Reduzierung)
Anzahl der zusammengeführten technischen Schuldenziehanforderungen pro Woche (Ziel: 2-3x Erhöhung)
Durchschnittliche Anzahl von Überprüfungszyklen pro Umgestaltungs-Pullanforderung (bewerten, ob dies erhöht oder verringert wurde)

Qualitätsmetriken

Stellen Sie sicher, dass sich die Qualität zusammen mit der Geschwindigkeit verbessert.

Anzahl der Linter-Warnungen (dieser sollte abnehmen)
Testabdeckungsprozentsatz (dieser sollte nach oben steigen)
Anzahl der Produktionsvorfälle im Zusammenhang mit umgestaltetem Code (bewerten, ob sich dies geändert hat)

Ingenieurzufriedenheit

Führen Sie regelmäßig eine Umfrage in Ihrem Team durch:

Verbringen Ingenieure weniger Zeit mit routineren Wartungen?
Konzentrieren sich Codeüberprüfungen eher auf Architektur und weniger auf Stil?
Ist das Onboarding für neue Teammitglieder schneller?

Problembehandlung

          Copilot schlägt falsche Änderungen vor

Wenn Copilot durchgängig Code vorschlägt, der nicht Ihren Anforderungen entspricht:

Überprüfen Sie Ihre benutzerdefinierten Anweisungen – sie sind möglicherweise zu vage oder widersprüchlich.
Bereitstellen eines spezifischeren Kontexts in Ihren Eingabeaufforderungen
Hinzufügen von Beispielen für guten Code zu Ihren benutzerdefinierten Anweisungen
Hinterlassen Sie detailliertes Feedback in Pull-Request-Bewertungen, um Copilot-Cloud-Agent die Probleme zu beheben.

Pull Requests sind zu groß, um überprüft zu werden.

Wenn Copilot-Cloud-Agent Pull-Anfragen erstellt, die schwer zu überprüfen sind:

Aufteilen großer Vorgänge in kleinere, fokussierte Probleme
Fordern Sie an, Copilot-Cloud-Agent jeweils eine Datei oder ein Verzeichnis zu behandeln.
Spezifischere Problembeschreibungen verwenden

Änderungen führen zu Testfehlern

Wenn bei der Umgestaltung Testfehler auftreten:

Sicherstellen, dass Ihre Testsuite vor der Verwendung zuverlässig ausgeführt wird Copilot-Cloud-Agent
Überprüfen Sie Copilot Änderungen sorgfältig vor dem Zusammenführen
Bitten Sie Copilot , Tests zusammen mit den Codeänderungen zu aktualisieren

Die Teamakzeptanz ist langsam

Wenn Ihr Team Copilot nicht für technische Schulden verwendet:

Teilen von Erfolgsgeschichten von Early Adopters
Demonstrieren von Zeiteinsparungen in Teambesprechungen
Beginnen Sie mit den lästigsten technischen Schuldenartikeln
Die Erstellung von benutzerdefinierten Anweisungen zu einer Teamaktivität machen

Conclusion

In diesem Tutorial haben Sie gelernt, wie Copilot Sie die technischen Schulden systematisch reduzieren. Jetzt wissen Sie, wie Sie:

Beheben Sie technische Schulden sofort mithilfe von Copilot in Ihrer IDE
Weisen Sie große Refaktorisierungsaufgaben an Copilot-Cloud-Agent zu.
Erstellen von benutzerdefinierten Anweisungen, die den Standards Ihres Teams entsprechen Copilot
Führen Sie ein Pilotprogramm aus, um den Ansatz zu überprüfen.
Die Auswirkungen der Maßnahme Copilotauf die technische Schulden

Durch die Automatisierung von Routine-Refaktorisierungs- und Wartungsaufgaben ermöglicht Ihnen Copilot, sich auf Architektur, Feature-Entwicklung und andere hochwertige Arbeiten zu konzentrieren.

Schnelle Umfrage

Haben Sie nach dem Lesen dieser Anleitung das Gefühl, dass Sie Copilot verwenden können, um die technischen Schulden in einer Codebasis zu reduzieren?

          <a href="https://docs.github.io/success-test/yes.html" target="_blank" class="btn btn-outline mt-3 mr-3 no-underline">
          <span>Yes</span></a><a href="https://docs.github.io/success-test/no.html" target="_blank" class="btn btn-outline mt-3 mr-3 no-underline"><span>No</span></a>

Nächste Schritte

        **Erweitern Sie Ihr Pilotprojekt**: Rollout für weitere Repositorys basierend auf Ihren Pilotergebnissen.

        **Abhängigkeitsupdates automatisieren**: Erstellen Sie wiederkehrende Vorgänge für Copilot-Cloud-Agent die Behandlung von Abhängigkeitsupdates.

Erstellen Sie eine Umgestaltungswarteschlange: Kennzeichnen Sie geeignete Aufgaben in Ihrem Backlog als gut für Copilot und weisen Sie dann regelmäßig eine Reihe von diesen Copilot zur Bearbeitung zu.

        **Bewährte Methoden freigeben**: Dokumentieren Sie erfolgreiche Eingabeaufforderungen und benutzerdefinierte Anweisungen für Ihr Team.

Weiterführende Lektüre

        [AUTOTITLE](/copilot/using-github-copilot/coding-agent)

        [AUTOTITLE](/copilot/tutorials/refactoring-code-with-github-copilot)

        [Verwenden von GitHub Copilot in Ihrer IDE: Tipps, Tricks und bewährte Methoden](https://github.blog/developer-skills/github/how-to-use-github-copilot-in-your-ide-tips-tricks-and-best-practices/) im GitHub Blog

        [5 Möglichkeiten zum Integrieren von GitHub Copilot-Cloud-Agent in Ihren Workflow](https://github.blog/ai-and-ml/github-copilot/5-ways-to-integrate-github-copilot-coding-agent-into-your-workflow/) im GitHub Blog

Verwenden von GitHub Copilot zur Verringerung der technischen Schulden

In diesem Artikel