Utilisation d’instructions personnalisées pour déverrouiller la puissance de la révision du code Copilot

Découvrez comment rédiger des instructions personnalisées efficaces qui aident GitHub Copilot à fournir des révisions de code plus pertinentes et utilisables.

Dans cet article

Présentation

GitHub Copilot la révision du code peut être personnalisée à l’aide de fichiers d’instructions pour adapter l’expérience de révision aux besoins et aux normes de codage de votre équipe. Toutefois, l’écriture d’instructions personnalisées efficaces nécessite de comprendre comment Copilot traite ces instructions et quelles approches fonctionnent le mieux.

Dans ce tutoriel, vous allez apprendre à écrire des instructions personnalisées claires et efficaces qui aident Copilot à fournir des révisions de code plus pertinentes. Vous découvrirez les meilleures pratiques pour structurer vos instructions, les pièges courants à éviter et les stratégies d’organisation des instructions dans différents fichiers.

Ce tutoriel concerne l’utilisation d’instructions personnalisées pour Révision du code Copilot. Pour obtenir une présentation plus générale de l’utilisation d’instructions personnalisées, consultez Configurez des instructions personnalisées pour GitHub Copilot.

Ce que vous allez apprendre

À la fin de ce tutoriel, vous comprendrez :

  • Comment écrire des instructions personnalisées concises et efficaces pour la révision du code.
  • Différence entre les instructions à l'échelle du référentiel et spécifiques à un chemin.
  • Modèles courants qui fonctionnent correctement avec Révision du code Copilot.
  • Quels types d'instructions ne sont pas pris en charge à l'heure actuelle.
  • Comment structurer et organiser vos instructions pour obtenir les meilleurs résultats.

Prerequisites

  • Accès à Révision du code Copilot.
  • Référentiel GitHub où vous pouvez créer des fichiers d’instructions personnalisés.
  • Connaissance de base de la syntaxe Markdown.

Comprendre comment GitHub Copilot traite les instructions du processus de révision du code.

Avant d’écrire des instructions personnalisées, il est utile de comprendre comment Révision du code Copilot les utilise. Lors de l’examen d’un pull request, Copilot lit vos fichiers d’instructions et les utilise pour guider son analyse. Toutefois, comme n’importe quel système d’IA, il présente des limitations :

  •         **Comportement non déterministe** : Copilot peut ne pas suivre toutes les instructions parfaitement à chaque fois.

  •         **Limites de contexte** : des fichiers d’instructions très longs peuvent entraîner l’oubli de certaines instructions.

  •         **Spécificité :** Des instructions claires et spécifiques fonctionnent mieux que des directives vagues.

Remarque

Révision du code Copilot lit uniquement les 4 000 premiers caractères d’un fichier d’instructions personnalisé. Toutes les instructions au-delà de cette limite n’affectent pas les révisions générées par Révision du code Copilot. Cette limite ne s’applique pas à Discussion avec Copilot ou Agent de programmation Copilot.

Gardez ces facteurs à l’esprit lorsque vous écrivez vos instructions, ils vous aideront à définir des attentes réalistes et à écrire des conseils plus efficaces.

Rédiger des instructions personnalisées efficaces

La clé des instructions personnalisées réussies est d’être claire, concise et spécifique. Voici les principes fondamentaux à suivre :

Conserver les instructions courtes et ciblées

Les fichiers d’instructions plus courts sont plus susceptibles d’être entièrement traités par Copilot. Commencez par un ensemble minimal d’instructions et ajoutez plus d’itérativement en fonction de ce qui fonctionne.

          **Bonne pratique** : limitez un fichier d’instructions unique à un maximum de 1 000 lignes. Au-delà de cela, la qualité des réponses peut se dégrader.

Utiliser une structure et une mise en forme claires

Copilot bénéficie d’instructions bien structurées avec :

  •         **Titres distincts** qui séparent différentes rubriques.

  •         **Points à puces** pour faciliter l’analyse et la référence.

  •         **Directives courtes et impératives** plutôt que de longs paragraphes de narration.

Par exemple, au lieu d’écrire :

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.

Écrire :

## Security Critical Issues

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

Fournir des exemples concrets

Comme lorsque vous expliquez un concept à un collègue, des exemples aident Copilot comprendre ce que vous voulez dire. Incluez des extraits de code montrant des modèles corrects et incorrects.

Par exemple:

## 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);
```

Organisation d’instructions sur les fichiers

Révision du code Copilot prend en charge deux types de fichiers d’instruction :

  1.        **
       `copilot-instructions.md`
       **: instructions à l’échelle du référentiel qui s’appliquent à tous les fichiers.

  2.        **
       `*.instructions.md`
       **: instructions spécifiques au chemin d’accès qui s’appliquent à certains fichiers ou répertoires.

Utilisez des instructions spécifiques au chemin pour garder Copilot concentré et empêcher l'application de règles spécifiques au langage aux fichiers inappropriés.

Quand utiliser des instructions à l’échelle du référentiel

Utiliser copilot-instructions.md pour :

  • Normes et instructions générales de l’équipe

  • Exigences de sécurité universelles

  • Préoccupations croisées telles que la philosophie de gestion des erreurs

  • Attentes en matière de documentation

            **Exemple de structure pour `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

Quand utiliser des instructions spécifiques au chemin d’accès

Utilisez des *.instructions.md fichiers avec la applyTo propriété frontmatter pour :

  • Normes de codage spécifiques au langage

  • Modèles spécifiques au framework

  • Problèmes de sécurité spécifiques à la technologie

  • Différentes règles pour différentes parties de votre codebase

            **Exemple : instructions spécifiques à Python**

Créez un fichier appelé python.instructions.md dans le .github/instructions répertoire :

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()
```

          **Exemple : instructions spécifiques au serveur frontal**

Créez un fichier appelé frontend.instructions.md dans le .github/instructions répertoire :

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

Fractionnant des ensembles d’instructions complexes

Pour les dépôts volumineux avec de nombreuses composantes, divisez les instructions en plusieurs fichiers ciblés.

.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

Chaque fichier doit avoir un objectif clair, spécifique et un frontmatter approprié applyTo si nécessaire.

En fonction de ce qui fonctionne bien avec Révision du code Copilot, voici un modèle recommandé pour structurer vos instructions :

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

Adaptez cette structure à vos besoins spécifiques, mais conservez le format de sectionnement clair et de point à puces.

Éléments à ne pas inclure dans les instructions personnalisées

Comprendre ce que Révision du code Copilot ne prend actuellement pas en charge vous permet d’éviter de perdre du temps sur les instructions qui ne fonctionnent pas.

Types d’instructions non pris en charge

Révision du code Copilot ne prend actuellement pas en charge les instructions qui tentent de :

          **Modifiez l’expérience utilisateur ou la mise en forme** :

  • Use bold text for critical issues

  • Change the format of review comments

  • Add emoji to comments

            **Modifiez le commentaire de l'aperçu de la pull request** :

  • Include a summary of security issues in the PR overview

  • Add a testing checklist to the overview comment

            **Modifiez la fonction principale de GitHub Copilot** :

  • Block a PR from merging unless all Révision du code Copilot comments are addressed

  • Generate a changelog entry for every PR

            **Suivez les liens externes** :

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

    Solution de contournement : copiez le contenu approprié directement dans votre fichier d’instructions à la place

            **Améliorations vagues de la qualité** :

  • Be more accurate

  • Don't miss any issues

  • Be consistent in your feedback

Ces types d’instructions ajoutent du bruit sans améliorer l’efficacité de Copilot, car il est déjà optimisé pour fournir des analyses précises et cohérentes.

Test et itération sur vos instructions

La meilleure approche pour créer des instructions personnalisées efficaces consiste à démarrer petit et itérer en fonction des résultats.

Commencer avec un jeu d’instructions minimal

Commencez par 10 à 20 instructions spécifiques qui répondent à vos besoins de révision les plus courants, puis testez si celles-ci influencent Révision du code Copilot de la façon que vous avez prévue.

Tester avec de véritables pull requests

Après avoir créé vos instructions :

  1. Ouvrez un pull request dans votre référentiel.
  2. Demandez une révision de Copilot.
  3. Observez les instructions qu’il suit efficacement.
  4. Notez les instructions qui sont constamment manquées ou mal interprétées.

Itérer en fonction des résultats

Ajoutez de nouvelles instructions une par une ou dans de petits groupes :

  1. Identifiez un modèle que Copilot pourrait mieux examiner.
  2. Ajoutez une instruction spécifique pour ce modèle.
  3. Testez avec une nouvelle pull request.
  4. Affinez l’instruction en fonction des résultats.

Cette approche itérative vous aide à comprendre ce qui fonctionne et à concentrer vos fichiers d’instructions.

Exemple : Suivre des instructions personnalisées pour la révision du code

Voici un exemple complet qui incorpore toutes les meilleures pratiques de ce tutoriel :

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

## Purpose

These instructions guide Révision du code Copilot 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.

          **Fichier: `.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>`)

Dépannage des problèmes courants

Si Révision du code Copilot ne suit pas vos instructions comme vous l'attendiez, essayez ces solutions :

Problème : les instructions sont ignorées

          **Causes possibles** :

  • Le fichier d’instructions est trop long (plus de 1 000 lignes).

  • Les instructions sont vagues ou ambiguës.

  • Les instructions sont en conflit les unes avec les autres.

            **Solutions** :

  • Raccourcissez le fichier en supprimant des instructions moins importantes.

  • Réécrire des instructions vagues pour être plus spécifiques et exploitables.

  • Passez en revue les instructions conflictuelles et hiérarchiser les instructions les plus importantes.

Problème : Règles spécifiques à la langue appliquées aux fichiers incorrects

          **Causes possibles** :

  • Un frontmatter manquant ou incorrect applyTo .

  • Règles dans un fichier à l’échelle du référentiel au lieu d’un fichier spécifique au chemin d’accès.

            **Solutions** :

  • Ajoutez applyTo frontmatter aux fichiers d’instructions propres au chemin.

  • Déplacez les règles spécifiques à la langue du fichier copilot-instructions.md vers les fichiers appropriés *.instructions.md.

Problème : Comportement incohérent entre les révisions

          **Causes possibles** :

  • Les instructions sont trop nombreuses.

  • Les instructions manquent de spécificité.

  • Variabilité naturelle dans les réponses à l’IA.

            **Solutions** :

  • Concentrez-vous sur vos instructions de priorité la plus élevée.

  • Ajoutez des exemples concrets pour clarifier l’intention.

  • Acceptez que certaines variabilités sont normales pour les systèmes IA.

Conclusion

Les instructions personnalisées efficaces aident Révision du code Copilot à fournir des commentaires plus pertinents et exploitables, adaptés aux normes de votre équipe. En suivant les principes de ce tutoriel , en gardant les instructions concises, en fournissant une structure claire, en utilisant des exemples concrets et en organisant plusieurs fichiers, vous pouvez améliorer considérablement votre expérience de révision de code.

N’oubliez pas que la création d’instructions efficaces est un processus itératif. Commencez par un petit ensemble d’instructions ciblées, testez-les avec des demandes de tirage réelles et développez progressivement en fonction de ce qui fonctionne bien pour votre équipe.

Étapes suivantes