Verwenden von benutzerdefinierten Anweisungen zum Entsperren der Leistungsfähigkeit der Copilot-Codeüberprüfung

Erfahren Sie, wie Sie effektive benutzerdefinierte Anweisungen schreiben, die GitHub Copilot helfen, relevantere und umsetzbare Codeüberprüfungen bereitzustellen.

In diesem Artikel

Einleitung

GitHub Copilot Code-Review kann mithilfe von Anleitungsdateien angepasst werden, um die Review-Erfahrung an die Anforderungen und Codierungsstandards Ihres Teams anzupassen. Das Schreiben effektiver benutzerdefinierter Anweisungen erfordert jedoch ein Verständnis dafür, wie Copilot diese Anweisungen verarbeitet und welche Ansätze am besten funktionieren.

In diesem Tutorial lernen Sie, wie Sie klare, effektive benutzerdefinierte Anweisungen schreiben, die Copilot mehr relevante Codeüberprüfungen bereitstellen. Sie finden bewährte Methoden zum Strukturieren Ihrer Anweisungen, gängiger Fallstricke, die vermieden werden sollen, und Strategien zum Organisieren von Anweisungen in verschiedenen Dateien.

In diesem Lernprogramm wird gezeigt, wie benutzerdefinierte Anweisungen für Copilot-Codeüberprüfung verwendet werden. Eine allgemeinere Einführung in die Verwendung von benutzerdefinierten Anweisungen finden Sie unter Konfigurieren von benutzerdefinierten Anweisungen für GitHub Copilot.

Sie lernen Folgendes

Am Ende dieses Lernprogramms verstehen Sie Folgendes:

  • So schreiben Sie präzise, effektive benutzerdefinierte Anweisungen für die Codeüberprüfung.
  • Der Unterschied zwischen repositoryweiten und pfadspezifischen Anweisungen.
  • Allgemeine Muster, die gut mit Copilot-Codeüberprüfung funktionieren.
  • Welche Arten von Anweisungen derzeit nicht unterstützt werden.
  • Die Strukturierung und Organisation Ihrer Anweisungen für beste Ergebnisse.

Voraussetzungen

  • Zugriff auf Copilot-Codeüberprüfung.
  • Ein GitHub Repository, in dem Sie benutzerdefinierte Anweisungsdateien erstellen können.
  • Grundlegende Kenntnisse mit der Markdown-Syntax.

Grundlegendes dazu, wie GitHub Copilot Codeüberprüfung Anweisungen verarbeitet

Bevor Sie benutzerdefinierte Anweisungen schreiben, ist es hilfreich, zu verstehen, wie Copilot-Codeüberprüfung sie verwendet. Beim Überprüfen einer Pullanforderung liest Copilot Ihre Anweisungsdateien und verwendet sie, um die Analyse zu leiten. Wie jedes KI-System hat es jedoch Einschränkungen:

  •         **Nicht deterministisches Verhalten**: Copilot folgen möglicherweise nicht jedes Mal perfekt jeder Anweisung.

  •         **Kontextbeschränkungen**: Sehr lange Anweisungsdateien können dazu führen, dass einige Anweisungen übersehen werden.

  •         **Spezifitätsfragen**: Klare, spezifische Anweisungen funktionieren besser als vage Richtlinien.

Hinweis

Copilot-Codeüberprüfung liest nur die ersten 4.000 Zeichen einer benutzerdefinierten Anweisungsdatei. Alle Anweisungen, die über diese Grenze hinausgehen, wirken sich nicht auf die von Copilot-Codeüberprüfung generierten Rezensionen aus. Dieser Limit gilt nicht für Copilot-Chat oder Copilot-Programmierassistent.

Beachten Sie diese Faktoren beim Schreiben Ihrer Anweisungen – sie helfen Ihnen dabei, realistische Erwartungen festzulegen und effektivere Anleitungen zu schreiben.

Schreiben hilfreicher benutzerdefinierter Anweisungen

Der Schlüssel zu erfolgreichen benutzerdefinierten Anweisungen besteht darin, klar, präzise und spezifisch zu sein. Hier sind die wichtigsten Prinzipien zu befolgen:

Halten Sie Anweisungen kurz und fokussiert

Kürzere Anweisungsdateien werden wahrscheinlicher von Copilot vollständig verarbeitet. Beginnen Sie mit einem minimalen Satz von Anweisungen, und fügen Sie basierend auf dem, was funktioniert, iterativ hinzu.

          **Bewährte Methode**: Beschränken Sie jede einzelne Anweisungsdatei auf maximal 1.000 Zeilen. Darüber hinaus kann sich die Qualität der Antworten verschlechtern.

Klare Struktur und Formatierung verwenden

Copilot profitiert von gut strukturierten Anweisungen mit:

  •         **Unterschiedliche Überschriften** , die unterschiedliche Themen trennen.

  •         **Aufzählungspunkte** für einfaches Scannen und Verweisen.

  •         **Kurze, imperative Direktiven** anstelle langer erzählerischer Absätze.

Statt beispielsweise Folgendes zu schreiben:

When you're reviewing code, it would be good if you could try to look for
situations where developers might have accidentally left in sensitive
information like passwords or API keys, and also check for security issues.

Schreiben:

## Security Critical Issues

- Check for hardcoded secrets, API keys, or credentials
- Look for SQL injection and XSS vulnerabilities
- Verify proper input validation and sanitization

Konkrete Beispiele bereitstellen

Genau wie wenn Sie einem Kollegen ein Konzept erläutern, helfen Beispiele Copilot, zu verstehen, was Sie meinen. Fügen Sie Codeausschnitte mit korrekten und falschen Mustern hinzu.

Beispiel:

## Naming Conventions

Use descriptive, intention-revealing names.

```javascript
// Avoid
const d = new Date();
const x = users.filter(u => u.active);

// Prefer
const currentDate = new Date();
const activeUsers = users.filter(user => user.isActive);
```

Organisieren von Anweisungen in Dateien

Copilot-Codeüberprüfung unterstützt zwei Arten von Instruktionsdateien:

  1.        **
       `copilot-instructions.md`
       **: Repositoryweite Anweisungen, die für alle Dateien gelten.

  2.        **
       `*.instructions.md`
       **: Pfadspezifische Anweisungen, die für bestimmte Dateien oder Verzeichnisse gelten.

Verwenden Sie pfadspezifische Anweisungen, um Copilot fokussiert zu halten und zu verhindern, dass sprachspezifische Regeln auf die falschen Dateien angewendet werden.

Wann man repositoryweite Anweisungen verwenden sollte

          `copilot-instructions.md` verwenden für:

  • Allgemeine Teamstandards und Richtlinien

  • Universelle Sicherheitsanforderungen

  • Querschneidende Anliegen wie die Fehlerbehandlungsphilosophie

  • Dokumentationserwartungen

            **Beispielstruktur für `copilot-instructions.md`**:
Markdown
# General Code Review Standards

## Code Quality Essentials

- Functions should be focused and appropriately sized
- Use clear, descriptive naming conventions
- Ensure proper error handling throughout

## Security Standards

- Never hardcode credentials or API keys
- Validate all user inputs
- Use parameterized queries to prevent SQL injection

## Documentation Expectations

- All public functions must include doc comments
- Complex algorithms should have explanatory comments
- README files must be kept up to date

Gründe für die Verwendung von pfadspezifischen Anweisungen

Verwenden Sie *.instructions.md Dateien mit der applyTo Frontmattereigenschaft für:

  • Sprachspezifische Codierungsstandards

  • Frameworkspezifische Muster

  • Technologiespezifische Sicherheitsbedenken

  • Unterschiedliche Regeln für unterschiedliche Teile Ihrer Codebasis

            **Beispiel: Python-spezifische Anweisungen**

Erstellen Sie eine Datei mit dem Namen python.instructions.md im Verzeichnis .github/instructions.

Text
---
applyTo: "**/*.py"
---

# Python Coding Conventions

## Naming Conventions

- Use snake_case for variables and functions
- Use PascalCase for class names
- Use UPPERCASE for constants

## Code Style

- Follow PEP 8 style guidelines
- Limit line length to 88 characters (Black formatter standard)
- Use type hints for function signatures

## Best Practices

- Use list comprehensions for simple transformations
- Prefer f-strings for string formatting
- Use context managers (with statements) for resource management

```python
# Avoid
file = open('data.txt')
content = file.read()
file.close()

# Prefer
with open('data.txt') as file:
    content = file.read()
```

          **Beispiel: Frontend-spezifische Anweisungen**

Erstellen Sie eine Datei mit dem Namen frontend.instructions.md im Verzeichnis .github/instructions.

Text
---
applyTo: "src/components/**/*.{tsx,jsx}"
---

# React Component Guidelines

## Component Structure

- Use functional components with hooks
- Keep components small and focused (under 200 lines)
- Extract reusable logic into custom hooks

## State Management

- Use useState for local component state
- Use useContext for shared state across components
- Avoid prop drilling beyond 2-3 levels

## Accessibility

- All interactive elements must be keyboard accessible
- Include appropriate ARIA labels
- Ensure color contrast meets WCAG AA standards

Aufteilen komplexer Anweisungssätze

Für große Repositorys mit vielen Bedenken unterteilen Sie Anweisungen in mehrere fokussierte Dateien:

.github/
  copilot-instructions.md          # General standards

.github/instructions/
  python.instructions.md           # Python-specific
  javascript.instructions.md       # JavaScript-specific
  security.instructions.md         # Security-specific
  api.instructions.md              # API-specific

Jede Datei sollte bei Bedarf einen klaren, spezifischen Zweck und einen geeigneten applyTo Frontmatter haben.

Anhand dessen, was gut mit Copilot-Codeüberprüfung funktioniert, ist hier eine empfohlene Vorlage zur Strukturierung Ihrer Anweisungen:

Text
---
applyTo: "**/*.{js,ts}"  # If this is a path-specific file
---

# [Title: Technology or Domain Name] Guidelines

## Purpose

Brief statement of what this file covers and when these instructions apply.

## Naming Conventions

- Rule 1
- Rule 2
- Rule 3

## Code Style

- Style rule 1
- Style rule 2

```javascript
// Example showing correct pattern
```

## Error Handling

- How to handle errors
- What patterns to use
- What to avoid

## Security Considerations

- Security rule 1
- Security rule 2

## Testing Guidelines

- Testing expectation 1
- Testing expectation 2

## Performance

- Performance consideration 1
- Performance consideration 2

Passen Sie diese Struktur an Ihre spezifischen Anforderungen an, behalten Sie jedoch das klare Abschnitts- und Aufzählungszeichenformat bei.

Was nicht in benutzerdefinierte Anweisungen eingeschlossen werden soll

Wenn Sie wissen, was Copilot-Codeüberprüfung derzeit nicht unterstützt, hilft es Ihnen, keine Zeit für Anweisungen zu verschwenden, die nicht funktionieren.

Nicht unterstützte Anweisungstypen

Copilot-Codeüberprüfung unterstützt derzeit keine Anweisungen, die versuchen:

          **Ändern der Benutzeroberfläche oder Formatierung**:

  • Use bold text for critical issues

  • Change the format of review comments

  • Add emoji to comments

            **Ändern Sie den Übersichtskommentar der Pull-Anforderung**:

  • Include a summary of security issues in the PR overview

  • Add a testing checklist to the overview comment

            **Ändern Sie die Kernfunktion von GitHub Copilot**:

  • Block a PR from merging unless all Copilot-Codeüberprüfung comments are addressed

  • Generate a changelog entry for every PR

            **Folgen Sie externen Links**:

  • Review this code according to the standards at https://example.com/standards

    Problemumgehung: Kopieren Sie den relevanten Inhalt stattdessen direkt in Ihre Anweisungsdatei.

            **Vage Qualitätsverbesserungen**:

  • Be more accurate

  • Don't miss any issues

  • Be consistent in your feedback

Diese Arten von Anweisungen fügen Rauschen hinzu, ohne Copilot's Effektivität zu verbessern, da sie bereits optimiert ist, um genaue, konsistente Überprüfungen bereitzustellen.

Testen und Iterieren Ihrer Anweisungen

Der beste Ansatz zur Erstellung effektiver benutzerdefinierter Anweisungen besteht darin, klein zu beginnen und auf Grundlage der Ergebnisse schrittweise zu verbessern.

Beginnen mit einem minimalen Anweisungssatz

Beginnen Sie mit 10 bis 20 spezifischen Anweisungen, die Ihren am häufigsten verwendeten Überprüfungsanforderungen entsprechen, und testen Sie dann, ob diese Copilot-Codeüberprüfung in der von Ihnen beabsichtigten Weise beeinflussen.

Testen mit echten Pullanforderungen

Nach dem Erstellen Ihrer Anweisungen:

  1. Öffnen Sie eine Pull-Anforderung in Ihrem Repository.
  2. Fordern Sie eine Rezension von Copilot an.
  3. Beachten Sie, welche Anweisungen es effektiv befolgt.
  4. Beachten Sie alle Anweisungen, die konsistent verpasst oder falsch interpretiert werden.

Iterieren basierend auf Ergebnissen

Fügen Sie jeweils einzeln oder in kleinen Gruppen neue Anweisungen hinzu:

  1. Identifizieren Sie ein Muster, das Copilot besser überprüfen könnte.
  2. Fügen Sie eine bestimmte Anweisung für dieses Muster hinzu.
  3. Testen Sie mit einer neuen Pullanforderung.
  4. Verfeinern Sie die Anweisung basierend auf den Ergebnissen.

Dieser iterative Ansatz hilft Ihnen zu verstehen, was funktioniert und hält Ihre Anweisungsdateien fokussiert.

Beispiel: Ausführen von benutzerdefinierten Anweisungen für die Codeüberprüfung

Hier ist ein vollständiges Beispiel, das alle bewährten Methoden aus diesem Lernprogramm enthält:

          **Datei: `.github/copilot-instructions.md`**
Markdown
# General Code Review Standards

## Purpose

These instructions guide Copilot-Codeüberprüfung across all files in this repository.
Language-specific rules are in separate instruction files.

## Security Critical Issues

- Check for hardcoded secrets, API keys, or credentials
- Look for SQL injection and XSS vulnerabilities
- Verify proper input validation and sanitization
- Review authentication and authorization logic

## Performance Red Flags

- Identify N+1 database query problems
- Spot inefficient loops and algorithmic issues
- Check for memory leaks and resource cleanup
- Review caching opportunities for expensive operations

## Code Quality Essentials

- Functions should be focused and appropriately sized (under 50 lines)
- Use clear, descriptive naming conventions
- Ensure proper error handling throughout
- Remove dead code and unused imports

## Review Style

- Be specific and actionable in feedback
- Explain the "why" behind recommendations
- Acknowledge good patterns when you see them
- Ask clarifying questions when code intent is unclear

## Testing Standards

- New features require unit tests
- Tests should cover edge cases and error conditions
- Test names should clearly describe what they test

Always prioritize security vulnerabilities and performance issues that could impact users.

          **Datei: `.github/instructions/typescript.instructions.md`**
Text
---
applyTo: "**/*.{ts,tsx}"
---

# TypeScript Development Standards

## Type Safety

- Avoid using `any` type—use `unknown` or specific types instead
- Use strict null checks (no `null` or `undefined` without explicit handling)
- Define interfaces for all object shapes

```typescript
// Avoid
function processData(data: any) {
    return data.value;
}

// Prefer
interface DataShape {
    value: string;
}

function processData(data: DataShape): string {
    return data.value;
}
```

## Naming Conventions

- Use PascalCase for types, interfaces, and classes
- Use camelCase for variables, functions, and methods
- Use UPPER_CASE for constants

## Modern TypeScript Patterns

- Use optional chaining (`?.`) and nullish coalescing (`??`)
- Prefer `const` over `let`; never use `var`
- Use arrow functions for callbacks and short functions

## React-Specific (for .tsx files)

- Use functional components with TypeScript props interfaces
- Type all props and state explicitly
- Use proper event types (e.g., `React.ChangeEvent<HTMLInputElement>`)

Behandeln allgemeiner Probleme

Wenn Copilot-Codeüberprüfung Ihren Anweisungen nicht wie erwartet folgt, probieren Sie diese Lösungen aus:

Problem: Anweisungen werden ignoriert.

          **Mögliche Ursachen**

  • Die Anweisungsdatei ist zu lang (über 1.000 Zeilen).

  • Anweisungen sind vage oder mehrdeutig.

  • Anweisungen stehen miteinander in Konflikt.

            **Lösungen**:

  • Kürzen Sie die Datei, indem Sie weniger wichtige Anweisungen entfernen.

  • Schreiben Sie vage Anweisungen um, um spezifischer und umsetzbarer zu sein.

  • Überprüfen Sie nach widersprüchlichen Anweisungen, und priorisieren Sie die wichtigsten Anweisungen.

Problem: Sprachspezifische Regeln, die auf falsche Dateien angewendet wurden

          **Mögliche Ursachen**

  • Fehlender oder falscher applyTo Frontmatter.

  • Regeln in repositoryweiten Dateien statt pfadspezifischer Datei.

            **Lösungen**:

  • Fügen Sie applyTo Frontmatter zu pfadspezifischen Anweisungsdateien hinzu.

  • Verschieben Sie sprachspezifische Regeln von copilot-instructions.md in die entsprechenden *.instructions.md Dateien.

Problem: Inkonsistentes Verhalten bei Rezensionen

          **Mögliche Ursachen**

  • Anweisungen sind zu vielfältig.

  • Anweisungen fehlen Spezifität.

  • Natürliche Variabilität bei KI-Antworten.

            **Lösungen**:

  • Konzentrieren Sie sich auf Ihre Anweisungen mit höchster Priorität.

  • Fügen Sie konkrete Beispiele hinzu, um die Absicht zu verdeutlichen.

  • Akzeptieren Sie, dass einige Variabilität für KI-Systeme normal ist.

Conclusion

Effektive benutzerdefinierte Anweisungen helfen Copilot-Codeüberprüfung, relevanteres und umsetzbares Feedback zu bieten, das auf die Standards Ihres Teams zugeschnitten ist. Indem Sie die Prinzipien in diesem Lernprogramm befolgen – Anleitungen präzise halten, klare Struktur bereitstellen, konkrete Beispiele verwenden und über mehrere Dateien hinweg organisieren – können Sie Ihre Codeüberprüfung erheblich verbessern.

Denken Sie daran, dass das Erstellen effektiver Anweisungen ein iterativer Prozess ist. Beginnen Sie mit einer kleinen Gruppe von fokussierten Anweisungen, testen Sie sie mit echten Pull-Anforderungen und erweitern Sie schrittweise basierend auf dem, was für Ihr Team gut funktioniert.

Nächste Schritte