Bewährte Methoden für die Verwendung von Copilot für die Arbeit an Aufgaben

Sicherstellen, dass deine Issues gut eingegrenzt sind

GitHub Copilot liefert bessere Ergebnisse, wenn klare, gut eingegrenzte Aufgaben zugewiesen werden. Eine ideale Aufgabe umfasst:

• Eine klare Beschreibung des zu lösenden Problems oder der erforderlichen Arbeit.
• Vollständige Akzeptanzkriterien für eine gute Lösung (sollte es z. B. Komponententests geben?).
• Anweisungen zu den Dateien, die geändert werden müssen.

Wenn du eine Aufgabe an Copilot übergibst und dazu ein Issue zuweist, solltest du dir das Issue, das du Copilot zuweist, als Prompt vorstellen. Überleg dir, ob es wahrscheinlich ist, dass die Issuebeschreibung als KI-Prompt funktioniert und Copilot damit die erforderlichen Codeänderungen vornehmen kann.

Auswählen des richtigen Aufgabentyps, der Copilot zugewiesen werden soll

Während du mit Copilot arbeitest, bekommst du ein Gefühl für die Aufgabentypen, die sich am besten bearbeiten lassen. Zu Beginn solltest du Copilot einfachere Aufgaben übergeben, um die Funktionsweise als Programmier-Agent zu verfolgen. Du könntest Copilot z. B. auffordern, Fehler zu beheben, Benutzeroberflächenfeatures zu ändern, die Testabdeckung zu verbessern, Dokumentation zu aktualisieren, die Barrierefreiheit zu verbessern oder technische Schulden abzubauen.

Zu den Issues, die du möglicherweise selbst bearbeiten möchtest, anstatt sie Copilot zuzuweisen, gehören:

• Komplexe und breit angelegte Aufgaben

  • Breit angelegte, kontextreiche Umgestaltungsprobleme, die repositoryübergreifende Kenntnisse und Tests erfordern
  • Komplexe Issues, die das Verständnis von Abhängigkeiten und Legacycode erfordern
  • Aufgaben, die umfassende Domänenkenntnisse erfordern
  • Aufgaben, die wesentliche Geschäftslogik umfassen
  • Große Änderungen an einer Codebasis, die Entwurfskonsistenz erfordern

• Sensible und kritische Aufgaben

  • Produktionskritische Issues
  • Aufgaben im Zusammenhang mit Sicherheit, personenbezogenen Informationen, Konsequenzen für die Authentifizierung
  • Reaktion auf Incidents

• Nicht eindeutige Aufgaben

  • Aufgaben ohne klare Definition: Aufgaben mit nicht eindeutigen Anforderungen, offene Aufgaben, Aufgaben, bei deren Bearbeitung Unklarheiten überwunden werden müssen, um eine Lösung zu finden

• Lernaufgaben

  • Aufgaben, bei denen Entwickler etwas lernen möchten, um ein tieferes Verständnis zu erzielen

Verwenden von Kommentaren zum Durchlaufen eines Pull Requests

Die Arbeit mit Copilot an einem Pull Request ist ähnlich wie die Arbeit mit einem menschlichen Entwickler: Es ist üblich, dass für den Pull Request weitere Arbeit notwendig ist, bevor er zusammengeführt werden kann. Der Prozess für die Überführung des Pull Requests in einen Zustand, in dem er zusammengeführt werden kann, ist derselbe – ob der Pull Request von Copilot oder einem Menschen erstellt wird. Wenn du möchtest, kannst du selbst am Featurebranch arbeiten und Änderungen an den Pull Request pushen. Du kannst dem Pull Request aber auch nur Kommentare hinzufügen, die erklären, was deiner Auffassung nach falsch ist oder verbessert werden könnte, und es Copilot überlassen, die erforderlichen Änderungen vorzunehmen.

Copilot liest alle Kommentare, sobald sie von Benutzern mit Schreibzugriff übermittelt werden, und entscheidet, ob eine Aktion erforderlich ist. Anschließend werden die erforderlichen Änderungen vorgenommen, und zum Abschluss wird der Pull Request aktualisiert. Da Copilot Kommentare prüft, sobald sie übermittelt werden, ist es für den Fall, dass du wahrscheinlich mehrere Kommentare zu einem Pull Request erstellst, am besten, sie zu stapeln. Klicke dazu auf Start a review anstatt auf Add single comment. Du kannst dann all deine Kommentare gleichzeitig übermitteln, was dazu führt, dass Copilot deinen gesamten Review und nicht die einzelnen Kommentare getrennt bearbeitet.

Hinzufügen von benutzerdefinierten Anweisungen zu deinem Repository

Wenn du deinem Repository benutzerdefinierte Anweisungen hinzufügst, kannst du Copilot Anleitungen dazu geben, wie dein Projekt zu verstehen ist und wie die Änderungen zu erstellen, zu testen und zu überprüfen sind.

Wenn Copilot Änderungen in der eigenen Entwicklungsumgebung erstellen, testen und überprüfen kann, ist es wahrscheinlicher, gute Pull Requests zu erstellen, die schnell zusammengeführt werden können.

Füge einer .github/copilot-instructions.md-Datei im Repository Anweisungen hinzu. Weitere Informationen finden Sie unter Hinzufügen benutzerdefinierter Repositoryanweisungen für GitHub Copilot.

Dies ist ein Beispiel für eine effektive copilot-instructions.md-Datei:

This is a Go based repository with a Ruby client for certain API endpoints. It is primarily responsible for ingesting metered usage for GitHub and recording that usage. Please follow these guidelines when contributing:

## Code Standards

### Required Before Each Commit
- Run `make fmt` before committing any changes to ensure proper code formatting
- This will run gofmt on all Go files to maintain consistent style

### Development Flow
- Build: `make build`
- Test: `make test`
- Full CI check: `make ci` (includes build, fmt, lint, test)

## Repository Structure
- `cmd/`: Main service entry points and executables
- `internal/`: Logic related to interactions with other GitHub services
- `lib/`: Core Go packages for billing logic
- `admin/`: Admin interface components
- `config/`: Configuration files and templates
- `docs/`: Documentation
- `proto/`: Protocol buffer definitions. Run `make proto` after making updates here.
- `ruby/`: Ruby implementation components. Updates to this folder should include incrementing this version file using semantic versioning: `ruby/lib/billing-platform/version.rb`
- `testing/`: Test helpers and fixtures

## Key Guidelines
1. Follow Go best practices and idiomatic patterns
2. Maintain existing code structure and organization
3. Use dependency injection patterns where appropriate
4. Write unit tests for new functionality. Use table-driven unit tests when possible.
5. Document public APIs and complex logic. Suggest changes to the `docs/` folder when appropriate

Verwenden des Model Context Protocol (MCP)

Du kannst die Funktionen von Copilot-Programmier-Agent mit MCP erweitern. Auf diese Weise kann Copilot-Programmier-Agent Tools verwenden, die von lokalen MCP-Servern bereitgestellt werden. Weitere Informationen finden Sie unter Erweitern des Copilot-Programmier-Agent mit Model Context Protocol (MCP).

Vorinstallieren von Abhängigkeiten in der GitHub Copilot-Umgebung

Bei der Bearbeitung einer Aufgabe kann Copilot auf eine eigene Entwicklungsumgebung zugreifen, die von GitHub Actions unterstützt wird. Dort kann Copilot u. a. deinen Code erkunden, Änderungen vornehmen sowie automatisierte Tests und Linter ausführen.

Wenn Copilot Änderungen in der eigenen Entwicklungsumgebung erstellen, testen und überprüfen kann, ist es wahrscheinlicher, gute Pull Requests zu erstellen, die schnell zusammengeführt werden können.

Zu diesem Zweck werden die Abhängigkeiten deines Projekts benötigt. Copilot kann diese Abhängigkeiten über Versuch und Irrtum selbst ermitteln und installieren, was jedoch auf Grund der nicht deterministischen Eigenschaften großer Sprachmodelle (LLMs) ein langwieriger und unzuverlässiger Prozess sein kann.

Du kannst eine copilot-setup-steps.yml-Datei so konfigurieren, dass diese Abhängigkeiten vorab installiert werden, bevor der Agent mit der Arbeit beginnt, damit er sofort voll einsatzfähig ist. Weitere Informationen finden Sie unter Anpassen der Entwicklungsumgebung für den Copilot-Programmier-Agent.