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

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

          GitHub Copilot fournit de meilleurs résultats quand des tâches claires et bien délimitées sont attribuées. 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.

          Copilot, agent de codage a la possibilité de rechercher votre base de code, y compris la recherche de code sémantique, ce qui lui permet de trouver du code pertinent en fonction de la signification plutôt que simplement des correspondances de texte exactes. Même si vous ne spécifiez pas de chemins de fichier exacts dans une tâche, l’agent peut souvent découvrir le code approprié par lui-même.

Si vous passez une tâche à Copilot en affectant un problème, il est utile de considérer le problème que vous assignez à Copilot comme un déclencheur. Déterminez si la description du problème est susceptible de fonctionner en tant qu’invite d’intelligence artificielle et permet Copilot d’apporter les modifications de code requises.

Choix du bon type de tâches à donner aux systèmes Copilot

Au fur et à mesure que vous travaillez avec Copilot, vous aurez une idée des types de tâches auxquelles il est le mieux adapté. Au départ, vous pouvez commencer par donner Copilot des tâches plus simples pour voir comment il fonctionne en tant qu’agent de codage. Par exemple, vous pouvez commencer par demander à Copilot de corriger des bogues, modifier les fonctionnalités de l’interface utilisateur, améliorer la couverture des tests, mettre à jour la documentation, améliorer l’accessibilité ou résoudre des dettes techniques.

Les problèmes que vous pouvez choisir de travailler vous-même sur, plutôt que de les assigner à Copilot, incluent :

•         **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 pull request est comme travailler avec un développeur humain : il est souvent nécessaire que la pull request ait besoin d'un travail supplémentaire avant de pouvoir être fusionnée. Le processus pour amener la pull request à un état fusionnable est exactement le même lorsque la pull request est créée par Copilot que lorsqu'elle est créée par un humain.

De plus, vous pouvez :

• Mentionnez @copilot dans les commentaires sur le pull request, en expliquant ce que vous pensez être incorrect ou qui pourrait être amélioré, et Copilot enverra des commits directement à la branche du pull request.
• Demandez à Copilot de résoudre les conflits de fusion sur le pull request. Consultez Demander à GitHub Copilot d’apporter des modifications à une pull request existante.
• Travaillez sur la branche fonctionnelle vous-même et soumettez les modifications au pull request.

Après qu'un utilisateur disposant d'un accès en écriture mentionne @copilot dans un commentaire, Copilot commencera à apporter les modifications requises et mettra à jour la requête d'extraction une fois terminé. Étant donné que Copilot commence à examiner les commentaires dès qu’ils sont envoyés, si vous êtes susceptible d’effectuer plusieurs commentaires sur une demande de tirage, il est préférable de les traiter par lots en cliquant sur Démarrer une révision, plutôt que sur Ajouter un commentaire unique. Vous pouvez ensuite soumettre tous vos commentaires à la fois, ce qui vous Copilot permet de travailler sur l’ensemble de votre évaluation, plutôt que de travailler séparément sur des commentaires individuels.

Lorsqu'Copilot apporte des modifications à la pull request, le titre et le corps restent à jour 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 projet et comment compiler, tester et valider ses modifications.

Si Copilot est en mesure de compiler, de tester et de valider ses modifications dans son propre environnement de développement, il est plus susceptible de produire de bonnes requêtes de tirage 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 .github/copilot-instructions.md fichier à la racine de votre référentiel. Ce fichier doit contenir des informations sur votre projet, telles que la création et le test, ainsi que les normes ou conventions de codage que vous souhaitez Copilot suivre. Notez que les instructions s’appliquent également à Tchat Copilot et révision du code Copilot.

La première fois que vous demandez à Copilot de créer une pull request dans un dépôt donné, Copilot laissera un commentaire avec un lien pour générer automatiquement des instructions personnalisées. Vous pouvez également demander à Copilot de générer des instructions personnalisées à tout moment en utilisant notre commande 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 , tels que des tests unitaires ou des composants React, créez un ou plusieurs .github/instructions/**/*.instructions.md fichiers dans votre référentiel. Dans ces fichiers, incluez des informations sur les types de fichiers, telles que la façon de les générer et de les tester, ainsi que les normes de codage ou les conventions que vous souhaitez Copilot suivre.

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 [AUTOTITLE](/copilot/how-tos/configure-custom-instructions/add-organization-instructions).

Utilisation du protocole MCP (Model Context Protocol)

Vous pouvez étendre les capacités de Copilot, agent de codage par l'utilisation de MCP. Cela permet Copilot, agent de codage d’utiliser les outils fournis par les serveurs MCP locaux et distants. Le serveur MCP et le GitHubserveur MCP 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

Bien que les instructions personnalisées guident le comportement général de votre référentiel, agents personnalisés vous pouvez créer 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. Agents personnalisés sont définis en tant que fichiers Markdown appelés profils d’agent.

Voici quelques exemples de agents personnalisés que vous pourriez 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éritez des outils serveur MCP qui ont été configurés dans le référentiel, mais vous pouvez également configurer agents personnalisés pour n’avoir accès qu’à des outils spécifiques.

Vous pouvez utiliser agents personnalisés partout où vous utilisez Copilot, agent de codage, notamment lors de l’attribution d’un ticket ou en déclenchant une tâche.

Pour plus d’informations sur la création et la configuration 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

Tout en travaillant sur une tâche, Copilot a accès à son propre environnement de développement éphémère, alimenté par GitHub Actions, où il peut explorer votre code, apporter des modifications, exécuter des tests automatisés et desinters, etc.

Si Copilot est en mesure de générer, de tester et de valider leurs modifications dans son propre environnement de développement, il est plus susceptible de produire de bonnes pull requests susceptibles d'être fusionnées rapidement.

Cela nécessitera les dépendances de votre projet. Copilot peut découvrir et installer ces dépendances elle-même par le biais d’un processus d’essai et d’erreur, mais cela peut être lent et non fiable, compte tenu de la nature non déterministe des modèles de langage volumineux (LLMs).

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.