Bewährte Methoden für die Verwendung von GitHub Copilot für die Arbeit an Vorgängen

Hier erfährst du, wie du die besten Ergebnisse vom Copilot Codierungsassistent bekommst.

Wer kann dieses Feature verwenden?

Der Copilot Codierungsassistent ist mit den Plänen für GitHub Copilot Pro, GitHub Copilot Pro+, GitHub Copilot Business und GitHub Copilot Enterprise verfügbar. Der Agent ist in allen Repositorys verfügbar, die auf GitHub gespeichert sind, mit Ausnahme von Repositorys, die sich im Besitz von verwaltete Benutzerkonten befinden und für die er explizit deaktiviert wurde.
Sign up for Copilot

In diesem Artikel

Hinweis

Eine Einführung in Copilot Codierungsassistent findest du unter Informationen zu GitHub Copilot Coding-Assistent.

Sicherstellen, dass deine Probleme gut abgegrenzt 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. Überlegen Sie, ob es wahrscheinlich ist, dass die Problembeschreibung 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. Anfangs solltest du Copilot einfachere Aufgaben übergeben, um die Arbeitsweise als Codierungsagent zu beobachten. 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 Probleme
    • 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 zur Überarbeitung 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 an der Featurebranch arbeiten und Änderungen an die Pull-Anforderung übergeben.

Nachdem ein Benutzer mit Schreibzugriff @copilot in einem Kommentar erwähnt hat, beginnt Copilot, alle erforderlichen Änderungen vorzunehmen und aktualisiert den Pull Request, wenn die Änderungen abgeschlossen sind. 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.

Hinweis

Copilot reagiert ausschließlich auf Kommentare von Personen, die über Schreibzugriff auf das Repository verfügen.

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 Codierungsassistent 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 von benutzerdefinierten Repositoryanweisungen für GitHub Copilot.

Repository-weite Anweisungen

Um Anweisungen hinzuzufügen, die für alle Aufgaben gelten, die Copilot in Ihrem Repository zugewiesen sind, erstellen Sie eine .github/copilot-instructions.md-Datei im Stammverzeichnis Ihres Repositorys. Diese Datei sollte Informationen zu Ihrem Projekt enthalten, z. B. wie Sie es bauen und testen, sowie alle Codierungsstandards oder Konventionen, denen Sie Copilot folgen möchten. Beachten, dass die Anweisungen auch für Copilot-Chat und Copilot Codeüberprüfung 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 von benutzerdefinierten 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, an denen Copilot arbeiten wird, wie z. B. für Unit-Tests oder React-Komponenten, erstellen Sie eine oder mehrere .github/instructions/**/*.instructions.md-Dateien in Ihrem 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 beispielsweise Anweisungen für Playwright-Tests zu erstellen, können Sie eine Anleitungsdatei namens .github/instructions/playwright-tests.instructions.md mit dem folgenden 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

Organisationsweite benutzerdefinierte Anweisungen

Copilot Codierungsassistent nutzt die individuellen Anweisungen Ihrer Organisation als Teil ihrer Arbeit. Copilot Codierungsassistent priorisiert zunächst repository-weite benutzerdefinierte Anweisungen. Weitere Informationen zum Konfigurieren von benutzerdefinierten Anweisungen für die Organisation finden Sie unter Hinzufügen von benutzerdefinierten Anweisungen für die Organisation für GitHub Copilot.

Verwenden des Model Context Protocol (MCP)

Du kannst die Funktionen von Copilot Codierungsassistent mit MCP erweitern. Auf diese Weise kann Copilot Codierungsassistent Tools verwenden, die von lokalen MCP-Servern und MCP-Remoteservern bereitgestellt werden. Der GitHub MCP-Server und Playwright MCP-Server sind standardmäßig aktiviert. Weitere Informationen finden Sie unter Erweiterung des GitHub Copilot Codierungsagenten mit dem Model Context Protocol (MCP).

Erstellen von Benutzerdefinierte Agenten

Benutzerdefinierte Anleitungen helfen dabei, das allgemeine Verhalten von Copilot in dem Repository zu steuern, während Benutzerdefinierte Agenten vollständig spezialisierte Agents mit fokussierten Kenntnissen und maßgeschneiderten Toolkonfigurationen erstellen. Diese Agents sind für spezifische, wiederkehrende Workflows konzipiert, bei denen Domänenkompetenz und konsistentes Verhalten von entscheidender Bedeutung sind. Benutzerdefinierte Agents werden als Markdown-Dateien definiert, die als Agentenprofile bezeichnet werden.

Hier sind einige Beispiele für Benutzerdefinierte Agenten, die erstellt werden können.

  •         **Testspezialist**: Ein Agent, der mit bestimmten Testframeworks konfiguriert und sich auf Testabdeckung, Testqualität und bewährte Methoden konzentriert. Es kann auf Lese-, Such- und Bearbeitungstools beschränkt sein, um unbeabsichtigte Änderungen am Produktionscode zu verhindern und gleichzeitig eine umfassende Testabdeckung sicherzustellen.

  •         **Dokumentationsexperte**: Ein Agent, der sich auf das Erstellen und Verwalten der Projektdokumentation spezialisiert hat, mit umfassendem Wissen über Dokumentationsstandards, Stilführungslinien und die Möglichkeit, Code zu analysieren, um genaue API-Dokumentationen und Benutzerhandbücher zu generieren.

  •         **Python-Spezialist**: Ein sprachspezifischer Agent, der Python-Konventionen, beliebte Frameworks wie Django oder Flask versteht und PEP-Standards folgt. Es hätte spezielle Kenntnisse von Python-Tools, virtuellen Umgebungen und Testframeworks wie Pytest.

Standardmäßig übernehmen Benutzerdefinierte Agenten irgendwelche MCP-Servertools, die im Repository konfiguriert wurden, aber Sie können Benutzerdefinierte Agenten auch so konfigurieren, dass sie nur Zugriff auf bestimmte Tools haben.

Benutzerdefinierte Agenten können überall verwendet, wo Copilot Codierungsassistent verwendet wird, einschließlich der Zuweisung eines Problems oder der Aufforderung mit einer Aufgabe.

Weitere Informationen zum Erstellen und Konfigurieren von Benutzerdefinierte Agenten finden Sie unter Erstellen benutzerdefinierter Agents für Copilot Codierungsassistent.

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.

Um das zu tun, benötigt es die Abhängigkeiten Ihres Projekts. 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 GitHub Copilot-Codierungs-Agent.