Bewährte Methoden für die Verwendung von GitHub 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.

Du kannst auch @copilot in Kommentaren im Pull Request erwähnen, die erklären, was deiner Auffassung nach falsch ist oder verbessert werden könnte, und es Copilot überlassen, die erforderlichen Änderungen vorzunehmen. Alternativ kannst du selbst am Featurebranch arbeiten und Änderungen an den Pull Request pushen.

Nachdem ein Benutzer mit Schreibzugriffserwähnungen @copilot in einem Kommentar erwähnt, nimmt Copilot alle erforderlichen Änderungen vor und aktualisiert den Pull Request, sobald er abgeschlossen ist. 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.

Da Copilot Änderungen am Pull Request vornimmt, bleiben Titel und Text auf dem neuesten Stand, damit sie die aktuellen Änderungen widerspiegeln.

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.

Copilot-Programmier-Agent unterstützt eine Reihe verschiedener Typen von benutzerdefinierten Anweisungen:

• /.github/copilot-instructions.md
• /.github/instructions/**/*.instructions.md
• **/AGENTS.md
• /CLAUDE.md
• /GEMINI.md

Weitere Informationen finden Sie unter Hinzufügen benutzerdefinierter Repositoryanweisungen für GitHub Copilot.

Repositoryweite Anweisungen

Um Anweisungen hinzuzufügen, die für alle Aufgaben gelten, die Copilot in deinem Repository zugewiesen sind, erstelle eine .github/copilot-instructions.md-Datei im Stammverzeichnis deines Repositorys. Diese Datei sollte Informationen zu deinem Projekt enthalten, z. B. wie du es erstellst und testest, und alle Programmierstandards oder Konventionen, denen Copilot folgen soll. Beachten, dass die Anweisungen auch für Copilot Chat und Copilot Code Review gelten.

Wenn du Copilot zum ersten Mal aufforderst, einen Pull Request in einem bestimmten Repository zu erstellen, hinterlässt Copilot einen Kommentar mit einem Link zum automatischen Generieren benutzerdefinierter Anweisungen. Du kannst außerdem jederzeit Copilot mit dem empfohlenen Prompt bitten, benutzerdefinierte Anweisungen für dich zu generieren. Weitere Informationen findest du unter Hinzufügen benutzerdefinierter Repositoryanweisungen für GitHub Copilot.

Du kannst zudem jederzeit eigene benutzerdefinierte Anweisungen schreiben. 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

Pfadspezifische Anweisungen

Um Anweisungen hinzuzufügen, die für bestimmte Dateitypen gelten, arbeitet Copilot an Komponententests oder React-Komponenten und erstellt eine oder mehrere .github/instructions/**/*.instructions.md-Dateien in deinem Repository. Füge in diese Dateien Informationen zu den Dateitypen ein, z. B. wie sie erstellt und getestet werden, sowie alle Programmierstandards oder Konventionen, denen Copilot folgen soll.

Mithilfe des Globmusters im Vordergrund der Anweisungensdatei kannst du die Dateitypen angeben, auf die sie angewendet werden sollen. Um z. B. Anweisungen für Playwright-Tests zu erstellen, kannst du eine Anleitungsdatei namens .github/instructions/playwright-tests.instructions.md mit folgendem Inhalt erstellen:

---
applyTo: "**/tests/*.spec.ts"
---

## Playwright test requirements

When writing Playwright tests, please follow these guidelines to ensure consistency and maintainability:

1. **Use stable locators** - Prefer `getByRole()`, `getByText()`, and `getByTestId()` over CSS selectors or XPath
1. **Write isolated tests** - Each test should be independent and not rely on other tests' state
1. **Follow naming conventions** - Use descriptive test names and `*.spec.ts` file naming
1. **Implement proper assertions** - Use Playwright's `expect()` with specific matchers like `toHaveText()`, `toBeVisible()`
1. **Leverage auto-wait** - Avoid manual `setTimeout()` and rely on Playwright's built-in waiting mechanisms
1. **Configure cross-browser testing** - Test across Chromium, Firefox, and WebKit browsers
1. **Use Page Object Model** - Organize selectors and actions into reusable page classes for maintainability
1. **Handle dynamic content** - Properly wait for elements to load and handle loading states
1. **Set up proper test data** - Use beforeEach/afterEach hooks for test setup and cleanup
1. **Configure CI/CD integration** - Set up headless mode, screenshots on failure, and parallel execution

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 und MCP-Remoteservern bereitgestellt werden. Der MCP-Server von GitHub und der Playwright-MCP-Server sind standardmäßig aktiviert. Weitere Informationen finden Sie unter Erweitern des GitHub Copilot-Programmier-Agents 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 GitHub Copilot-Programmier-Agent.