Meilleures pratiques pour utiliser GitHub Copilot pour travailler sur des tâches

Assurez-vous que vos problèmes sont bien définis

GitHub Copilot obtient de meilleurs résultats lorsqu'on lui confie des tâches claires et bien définies. Une tâche idéale comprend :

• Une description claire du problème à résoudre ou du travail à effectuer.
• Compléter les critères d'acceptation sur ce à quoi ressemble une bonne solution (par exemple, doit-il y avoir des tests unitaires ?).
• Indications sur les fichiers à modifier.

Si vous passez une tâche à Copilot en lui assignant un problème, il est utile de considérer le problème que vous assignez à Copilot comme une invite. Examinez si la description du problème est susceptible de fonctionner en tant qu'invite de l'IA et si elle permettra à Copilot d'effectuer les modifications de code nécessaires.

Choisir le bon type de tâches à confier à Copilot

En travaillant avec Copilot, vous aurez une idée des types de tâches qui lui conviennent le mieux. Vous pouvez commencer par confier à Copilot des tâches plus simples, afin de voir comment il fonctionne en tant qu'agent de codage. Par exemple, vous pouvez commencer par demander à Copilot de corriger les bogues, de modifier les fonctionnalités de l'interface utilisateur, d'améliorer la couverture des tests, de mettre à jour la documentation, d'améliorer l'accessibilité ou de remédier à la dette technique.

Les questions que vous pouvez choisir de traiter vous-même, plutôt que de les confier à Copilot, sont les suivantes :

•         **Tâches complexes et de grande envergure**
  

  • Problèmes de refactorisation étendus et riches en contexte nécessitant des connaissances et des tests entre référentiels
  • Problèmes complexes nécessitant la compréhension des dépendances et du code hérité
  • Tâches nécessitant une connaissance approfondie du domaine
  • Tâches impliquant une logique métier substantielle
  • Modifications importantes apportées à une base de code nécessitant une cohérence de conception

•         **Tâches sensibles et critiques**
  

  • Questions critiques pour la production
  • Tâches impliquant la sécurité, les informations d’identification personnelle, les répercussions sur l’authentification
  • Réponse aux incidents

•         **Tâches ambiguës**
  

  • Tâches dépourvues de définition claire : tâches avec exigences ambiguës, tâches ouvertes, tâches nécessitant une incertitude pour trouver une solution

•         **Tâches d'apprentissage**
  

  • Tâches pour lesquelles le développeur souhaite apprendre afin d'approfondir ses connaissances

Utiliser les commentaires pour itérer sur une pull request

Travailler avec Copilot sur une demande d'extension est exactement comme travailler avec un développeur humain : il est courant que la demande d'extension nécessite un travail supplémentaire avant de pouvoir être fusionnée. Le processus pour amener la demande de retrait à un état fusionnable est exactement le même lorsque la demande de retrait est créée par Copilot que lorsqu'elle est créée par un humain.

Vous pouvez également mentionner @copilot dans les commentaires du pull request — en expliquant ce qui, selon vous, est incorrect ou pourrait être amélioré — et laissez Copilot apporter les modifications nécessaires. Vous pouvez également travailler vous-même sur la branche de fonctionnalité et envoyer les modifications vers le pull request.

Une fois qu'un utilisateur ayant un accès en écriture mentionne @copilot dans un commentaire, Copilot commence à apporter les modifications requises et met à jour le pull request lorsqu'il est terminé. Parce que Copilot commence à regarder les commentaires dès qu'ils sont soumis, si vous êtes susceptible de faire plusieurs commentaires sur une demande de traction, il est préférable de les grouper en cliquant sur Commencer un examen, plutôt que de cliquer sur Ajouter un seul commentaire. Vous pouvez ensuite soumettre tous vos commentaires en même temps, ce qui déclenche Copilot pour travailler sur l'ensemble de votre évaluation, plutôt que de travailler sur les commentaires individuels séparément.

Lorsque Copilot apporte des modifications à la pull request, il met à jour le titre et le corps afin qu'ils reflètent les modifications actuelles.

Ajouter des instructions personnalisées à votre référentiel

En ajoutant des instructions personnalisées à votre référentiel, vous pouvez guider Copilot sur la façon de comprendre votre project et comment générer, tester et valider ses modifications.

Si Copilot est capable de construire, tester et valider ses changements dans son propre environnement de développement, il est plus probable qu'il produise de bonnes pull requests qui peuvent être fusionnées rapidement.

Copilot, agent de codage prend en charge plusieurs types de fichiers d’instructions personnalisées :

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

Pour plus d’informations, consultez Ajout d’instructions personnalisées de référentiel pour GitHub Copilot.

Instructions à l’échelle du référentiel

Pour ajouter des instructions qui s’appliquent à toutes les tâches affectées à Copilot dans votre référentiel, créez un fichier .github/copilot-instructions.md à la racine de votre référentiel. Ce fichier doit contenir des informations sur votre projet, telles que comment le construire et le tester, ainsi que les normes de codage ou les conventions que vous souhaitez que Copilot suive. Notez que les instructions s’appliqueront également à Tchat Copilot et révision du code Copilot.

La première fois que vous demandez à Copilot de créer une demande de tirage dans un référentiel donné, Copilot laissera un commentaire avec un lien pour générer automatiquement des instructions personnalisées. Vous pouvez également demander à { % data variables.product.prodname_copilot_short %} de générer des instructions personnalisées à tout moment à l’aide de notre invite recommandée. Consultez Ajout d’instructions personnalisées de référentiel pour GitHub Copilot.

Vous pouvez également choisir d’écrire vos propres instructions personnalisées à tout moment. Voici un exemple de fichier copilot-instructions.md efficace :

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

Instructions spécifiques au chemin d’accès

Pour ajouter des instructions qui s’appliquent à des types spécifiques de fichiers Copilot fonctionneront, comme des tests unitaires ou des composants React, créez un ou plusieurs fichiers .github/instructions/**/*.instructions.md dans votre référentiel. Dans ces fichiers, incluez des informations sur les types de fichiers, telles que la manière de les générer et de les tester, ainsi que les normes ou conventions de codage que vous souhaitez que Copilot respecte.

En utilisant le modèle Glob dans l’en-tête du fichier d’instructions, vous pouvez spécifier les types de fichiers auxquels elles doivent s’appliquer. Par exemple, pour créer des instructions pour les tests Playwright, vous pouvez créer un fichier d’instructions appelé .github/instructions/playwright-tests.instructions.md avec le contenu qui suit :

---
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

Instructions personnalisées à l’échelle de l’organisation

Copilot, agent de codage tire parti des instructions personnalisées de votre organisation dans le cadre de son travail. Copilot, agent de codage hiérarchise d’abord les instructions personnalisées à l’échelle du référentiel. Pour plus d’informations sur la configuration des instructions personnalisées de l’organisation, consultez Ajout d’instructions personnalisées d’organisation pour GitHub Copilot.

Utilisation du protocole MCP (Model Context Protocol)

Vous pouvez étendre les capacités de Copilot, agent de codage en utilisant MCP. Cela permet à Copilot, agent de codage d'utiliser les outils fournis par les serveurs MCP locaux et distants. Les serveurs MCP GitHub et Playwright sont activés par défaut. Pour plus d’informations, consultez Extension de l'agent de codage GitHub Copilot avec le protocole de contexte de modèle (MCP).

Créer agents personnalisés

Alors que les instructions personnalisées vous aident à guider Copilot dans leur comportement général au sein de votre référentiel, agents personnalisés créent des agents entièrement spécialisés avec une expertise ciblée et des configurations d'outils personnalisées. Ces agents sont conçus pour des flux de travail spécifiques et récurrents où l’expertise du domaine et le comportement cohérent sont essentiels. Les Agents personnalisés sont définis sous forme de fichiers Markdown appelés profils d’agent.

Voici quelques exemples de agents personnalisés que vous pouvez créer :

•         **Spécialiste des tests** : un agent configuré avec des frameworks de test spécifiques et axé sur la couverture des tests, la qualité des tests et les meilleures pratiques de test. Il peut être limité aux outils de lecture, de recherche et de modification pour empêcher les modifications involontaires apportées au code de production tout en garantissant une couverture complète des tests.
  

•         **Expert en documentation** : agent spécialisé dans la création et la maintenance de la documentation de projet, avec une connaissance approfondie des normes de documentation, des guides de style et la possibilité d’analyser le code pour générer une documentation d’API précise et des guides utilisateur.
  

•         **Spécialiste Python** : agent spécifique au langage qui comprend les conventions Python, les frameworks populaires comme Django ou Flask, et suit les normes PEP. Il aurait des connaissances spécialisées sur les outils Python, les environnements virtuels et les frameworks de test comme pytest.
  

Par défaut, agents personnalisés héritent des outils de serveur MCP qui ont été configurés dans le référentiel, mais vous pouvez également configurer agents personnalisés pour avoir uniquement access à des outils spécifiques.

Vous pouvez utiliser les agents personnalisés partout où vous utilisez Copilot, agent de codage, y compris lors de l’attribution d’une issue ou lors de la formulation d’une tâche.

Pour plus d’informations sur la création et la configuration de agents personnalisés, consultez Création d’agents personnalisés pour Copilot, agent de codage.

Pré-installation des dépendances dans l'environnement de GitHub Copilot

Pendant que vous travaillez sur une tâche, Copilot a accès à son propre environnement de développement éphémère, propulsé par GitHub Actions, où il peut explorer votre code, apporter des modifications, exécuter des tests et des linters automatisés, etc.

Si Copilot est capable de construire, tester et valider ses changements dans son propre environnement de développement, il est plus probable qu'il produise de bonnes pull requests qui peuvent être fusionnées rapidement.

Cela nécessitera les dépendances de votre projet. Copilot peut découvrir et installer lui-même ces dépendances par un processus d'essais et d'erreurs - mais cela peut être lent et peu fiable, étant donné la nature non déterministe des grands modèles de langage (LLM).

Vous pouvez configurer un fichier copilot-setup-steps.yml pour préinstaller ces dépendances avant que l'agent ne démarre, afin qu'il soit opérationnel immédiatement. Pour plus d’informations, consultez Personnalisation de l’environnement de développement pour GitHub Agent de codage Copilot.