Bonnes pratiques pour l’interface CLI GitHub Copilot

Présentation

          CLI de GitHub Copilot est un assistant de codage IA natif terminal qui apporte directement des fonctionnalités agentiques à votre ligne de commande. 
          CLI Copilot peut fonctionner comme un chatbot, répondre à vos questions, mais sa véritable puissance réside dans sa capacité à travailler de manière autonome en tant que partenaire de codage, ce qui vous permet de déléguer des tâches et de superviser son travail.

Cet article fournit des conseils pour tirer le meilleur parti de CLI Copilot, de l'utilisation efficace des différentes commandes CLI à la gestion de l'accès de l'interface CLI aux fichiers. Considérez ces conseils comme des points de départ, puis testez ce qui fonctionne le mieux pour vos flux de travail.

Remarque

          CLI de GitHub Copilot évolue continuellement. Utilisez la `/help` commande pour afficher les informations les plus à jour.

1. Personnaliser votre environnement

Utiliser des fichiers d’instructions personnalisées

          CLI Copilot lit automatiquement des instructions à partir de plusieurs emplacements, ce qui vous permet de définir des normes à l’échelle de l’organisation et des conventions spécifiques au référentiel.

          **Emplacements pris en charge (dans l’ordre de découverte) :**

Emplacement	Scope
`~/.copilot/copilot-instructions.md`	Toutes les sessions (globales)
`.github/copilot-instructions.md`	Référentiel
`.github/instructions/*/.instructions.md`	Référentiel (modulaire)

          `AGENTS.md` (dans la racine Git ou cwd)            | Référentiel            |

| Copilot.md GEMINI.md CODEX.md | Référentiel |

Meilleure pratique

Les instructions de référentiel sont toujours prioritaires sur les instructions globales. Utilisez cette option pour appliquer des conventions d’équipe. Par exemple, il s’agit d’un fichier simple .github/copilot-instructions.md .

## Build Commands
- `npm run build` - Build the project
- `npm run test` - Run all tests
- `npm run lint:fix` - Fix linting issues

## Code Style
- Use TypeScript strict mode
- Prefer functional components over class components
- Always add JSDoc comments for public APIs

## Workflow
- Run `npm run lint:fix && npm test` after making changes
- Commit messages follow conventional commits format
- Create feature branches from `main`

Conseil

Conservez les instructions concises et exploitables. De longues instructions peuvent diluer l’efficacité.

Pour plus d’informations, consultez « À propos de la personnalisation des réponses GitHub Copilot ».

Configurer les outils autorisés

Gérez les outils Copilot qui peuvent s’exécuter sans demander d’autorisation. Lorsque Copilot vous demande l’autorisation pour une action, vous pouvez généralement choisir de ne l'autoriser que cette fois ou d'autoriser l’outil à être utilisé pour le reste de la session CLI.

Pour réinitialiser les outils précédemment approuvés, utilisez :

/reset-allowed-tools

Vous pouvez également préconfigurer les outils autorisés via des indicateurs CLI :

copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

          **Modèles d’autorisation courants :**

* shell(git:*) — Autoriser toutes les commandes Git * shell(npm run:*) — Autoriser tous les scripts npm * shell(npm run test:*) — Autoriser les commandes de test npm * write — Autoriser les écritures de fichiers

Sélectionnez votre modèle préféré

Utilisez cette option /model pour choisir parmi les modèles disponibles en fonction de la complexité de votre tâche :

Model	Idéal pour	Compromis

          **Claude Opus 4.5** (valeur par défaut) | Architecture complexe, débogage difficile, refactorisation nuanceée | Plus capable, mais utilise plus [de demandes Premium](/copilot/concepts/billing/copilot-requests#model-multipliers) |

| Claude Sonnet 4.5 | Codage quotidien, la plupart des tâches courantes | Rapide, économique, gère la plupart du travail bien | | GPT-5.2 Codex | Génération de code, révision du code, implémentations simples | Excellent pour examiner le code produit par d’autres modèles |

          **Recommendations:**

* L’opus 4.5 est idéal pour les tâches nécessitant un raisonnement profond, une conception de système complexe, une investigation subtile des bogues ou une compréhension approfondie du contexte. * Basculez vers Sonnet 4.5 pour les tâches courantes où la vitesse et l’efficacité des coûts sont importantes, il gère la majorité des codages quotidiens efficacement. * Utilisez Le Codex pour la génération de code à volume élevé et comme deuxième avis pour examiner le code produit par d’autres modèles.

Vous pouvez changer de modèle en cours de session avec /model lorsque la complexité des tâches évolue.

Si votre organisation ou entreprise a configuré des modèles personnalisés à l’aide de leurs propres clés API de fournisseur LLM, ces modèles apparaissent également en /model bas de la liste.

Utiliser votre propre fournisseur de modèles

Vous pouvez configurer CLI Copilot pour utiliser votre propre fournisseur de modèles au lieu de GitHubmodèles hébergés. Exécutez copilot help providers pour les instructions d'installation complètes.

          **Considérations clés :**

Votre modèle doit prendre en charge l’appel d’outils (appel de fonction) et la diffusion en continu. CLI Copilot retourne une erreur si l’une ou l’autre des fonctionnalités est manquante.
Pour obtenir de meilleurs résultats, utilisez un modèle avec une fenêtre contextuelle d’au moins 128 000 jetons.
Les sous-agents intégrés (/review, explorer /task, /fleet) héritent automatiquement de la configuration de votre fournisseur.
Les estimations de coût des demandes Premium sont masquées lors de l’utilisation de votre propre fournisseur. L’utilisation des jetons (entrées, sorties et nombres de caches) est toujours affichée.

        `/delegate` fonctionne uniquement si vous êtes également connecté à GitHub. Il transfère la session au côté GitHubserveur, et non à Copilotvotre fournisseur.

Consultez Utilisation de votre propre fournisseur de modèles.

2. Planifier avant de coder

Mode plan

          **Les modèles obtiennent des taux de réussite plus élevés lorsqu’un plan concret est à suivre.** En mode plan, Copilot crée un plan d’implémentation structuré avant l’écriture d’un code.

Appuyez sur Maj + + pour basculer entre le mode normal et le mode plan. En mode plan, tous les prompts que vous entrez activeront le workflow du plan.

Vous pouvez également utiliser la /plan commande en mode normal pour obtenir le même effet.

          **Exemple d’invite (en mode normal) :**

/plan Add OAuth2 authentication with Google and GitHub providers

          **Que se passe-t-il :**

* Copilot analyse votre requête et votre base de code. * Pose des questions de clarification pour s’aligner sur les exigences et l’approche.

Crée un plan d’implémentation structuré avec des cases à cocher.
Enregistre le plan dans plan.md de votre dossier de session.

        **Attend votre approbation** avant l’implémentation.

Vous pouvez appuyer sur Ctrl+y pour afficher et modifier le plan dans votre éditeur par défaut pour les fichiers Markdown.

          **Exemple de sortie de plan :**

# Implementation Plan: OAuth2 Authentication

## Overview
Add social authentication using OAuth2 with Google and GitHub providers.

## Tasks
- [ ] Install dependencies (passport, passport-google-oauth20, passport-github2)
- [ ] Create authentication routes in `/api/auth`
- [ ] Implement passport strategies for each provider
- [ ] Add session management middleware
- [ ] Create login/logout UI components
- [ ] Add environment variables for OAuth credentials
- [ ] Write integration tests

## Detailed Steps
1. **Dependencies**: Add to package.json...
2. **Routes**: Create `/api/auth/google` and `/api/auth/github`...

Quand utiliser le mode plan

Scénario	Utiliser le mode plan ?
Modifications complexes de fichiers multiples
Refactorisation avec de nombreux points de contact
Nouvelle implémentation de fonctionnalités
Correctifs de bogues rapides
Modifications de fichier unique

Le workflow exploration → planification → codage → commit

Pour obtenir de meilleurs résultats sur les tâches complexes :

```
        **Explorez** :
```
Read the authentication files but don't write code yet
```
        **Plan** :
```
/plan Implement password reset flow
```
        **Révision** :
```
Vérifier le plan, suggérer des modifications
```
        **Implémenter** :
```
Proceed with the plan
```
        **Vérifier** :
```
Run the tests and fix any failures
```
        **Commit** :
```
Commit these changes with a descriptive message

3. Tirer parti des sessions infinies

Gestion automatique des fenêtres de contexte

          CLI Copilot propose **des sessions infinies**. Vous n'avez pas besoin de vous inquiéter de manquer de contexte. Le système gère automatiquement le contexte par le biais d’un compactage intelligent qui résume l’historique des conversations tout en préservant les informations essentielles.

          **Emplacement de stockage de session :**

~/.copilot/session-state/{session-id}/
├── events.jsonl      # Full session history
├── workspace.yaml    # Metadata
├── plan.md           # Implementation plan (if created)
├── checkpoints/      # Compaction history
└── files/            # Persistent artifacts

Remarque

Si vous avez besoin de déclencher manuellement un compactage, utilisez /compact. Cela est rarement nécessaire, car le système le gère automatiquement.

Commandes de gestion de session

Pour afficher des informations sur la session CLI active, entrez :

/session

Pour afficher la liste des points de contrôle de session, entrez :

/session checkpoints

Remarque

Un point de contrôle est créé lorsque le contexte de session est compacté et vous permet d’afficher le contexte de synthèse créé Copilot .

Pour afficher les détails d’un point de contrôle spécifique, entrez :

/session checkpoints NUMBER

où NUMBER spécifie le point de contrôle à afficher.

Pour afficher les fichiers temporaires qui ont été créés pendant la session active—par exemple, les artefacts créés par Copilot qui ne devraient pas être enregistrés dans le référentiel—entrez :

/session files

Pour afficher le plan actuel (s’il Copilot en a généré un), entrez :

/session plan

Bonne pratique : Conserver la concentration lors des sessions

Bien que les sessions infinies permettent un travail de longue durée, les sessions axées produisent de meilleurs résultats :

Utiliser /clear ou /new entre des tâches non liées.
Cela réinitialise le contexte et améliore la qualité de la réponse.
Pensez-y comme commencer une nouvelle conversation avec un collègue.

La commande `/context`

Visualisez l’utilisation actuelle du contexte avec /context. Il montre une répartition des éléments suivants :

Jetons système/outils
Jetons d’historique des messages
Espace libre
Allocation de mémoire tampon

4. Déléguer le travail efficacement

La commande `/delegate`

          **Déchargez le travail à exécuter dans le cloud à l’aide de agent Copilot de cloud.** Ceci est particulièrement puissant pour :

Tâches qui peuvent s’exécuter de manière asynchrone.
Modifications apportées à d’autres référentiels.
Les opérations de longue durée que vous ne souhaitez pas attendre.
```
        **Exemple d’invite: :**
```

/delegate Add dark mode support to the settings page

          **Que se passe-t-il :**

Votre demande est envoyée à agent Copilot de cloud.
L’agent crée une pull request avec les modifications.
Vous pouvez continuer à travailler localement pendant que l’agent cloud fonctionne.

Quand utiliser `/delegate`

Utilisez `/delegate`.	Travailler localement
Tâches tangentielles	Travail de fonctionnalité de base
Mises à jour de la documentation	Débogage
Refactorisation de modules distincts	Exploration interactive

5. Flux de travail courants

Intégration de Codebase

Utilisez CLI Copilot comme partenaire de programmation en binôme lorsque vous rejoignez un nouveau projet. Par exemple, vous pouvez demander Copilot:

How is logging configured in this project?
What's the pattern for adding a new API endpoint?
Explain the authentication flow
Where are the database migrations?

Développement piloté par les tests

Associez-y CLI Copilot pour développer des tests.

Write failing tests for the user registration flow

        *Passez en revue et approuvez les tests.*

Now implement code to make all tests pass

        *Passez en revue l’implémentation.*

Commit with message "feat: add user registration"

Aide à la révision du code

/review Use Opus 4.5 and Codex 5.2 to review the changes in my current branch against `main`. Focus on potential bugs and security issues.

Opérations Git

          Copilot excelle dans les flux de travail Git :

What changes went into version `2.3.0`?
Create a PR for this branch with a detailed description
Rebase this branch against `main`
Resolve the merge conflicts in `package.json`

Examen des bogues

The `/api/users` endpoint returns 500 errors intermittently. Search the codebase and logs to identify the root cause.

Refactorisation

/plan Migrate all class components to functional components with hooks

Répondez ensuite aux interrogations formulées par Copilot. Examinez le plan qu’il crée et demandez-lui Copilot d’apporter des modifications si nécessaire. Lorsque vous êtes satisfait du plan, vous pouvez demander : Implement this plan

6. Modèles avancés

Travailler sur plusieurs référentiels

          **
          CLI Copilot fournit des flux de travail multi-dépôts flexibles**, un élément de différenciation clé pour les équipes travaillant sur des microservices, des monorepos ou des projets connexes.

          **Option 1 : Exécuter à partir d’un répertoire parent**

# Navigate to a parent directory containing multiple repos
cd ~/projects
copilot

          Copilot dispose désormais d’un accès à l’ensemble des référentiels enfants et peut y opérer simultanément. Ceci est idéal pour :

Architectures de microservices
Apporter des modifications coordonnées entre les dépôts associés

Refactorisation des modèles partagés entre les projets

        **Option 2 : Utiliser `/add-dir` pour développer l’accès**

# Start in one repo, then add others (requires full paths)
copilot
/add-dir /Users/me/projects/backend-service
/add-dir /Users/me/projects/shared-libs
/add-dir /Users/me/projects/documentation

          **Affichez et gérez les répertoires autorisés :**

/list-dirs

          **Exemple de flux de travail : modifications d’API coordonnées**

I need to update the user authentication API. The changes span:

- @/Users/me/projects/api-gateway (routing changes)
- @/Users/me/projects/auth-service (core logic)
- @/Users/me/projects/frontend (client updates)

Start by showing me the current auth flow across all three repos.

Cette fonctionnalité multi-référentiel permet :

Refactorisations croisées (mettez à jour un modèle partagé partout)
Modifications du contrat d’API avec les mises à jour du client
Documentation qui référence plusieurs bases de code
Mises à niveau des dépendances dans un monorepo

Utilisation d’images pour le travail de l’interface utilisateur

          Copilot peut utiliser des références visuelles. Faites **simplement glisser et déposez** des images directement dans l’entrée CLI ou référencez des fichiers image :

Implement this design: @mockup.png
Match the layout and spacing exactly

Listes de contrôle pour les migrations complexes

Pour les modifications à grande échelle :

Run the linter and write all errors to `migration-checklist.md` as a checklist.
Then fix each issue one by one, checking them off as you go.

Achèvement des tâches autonomes

Basculez en mode Autopilot pour permettre Copilot de travailler de manière autonome sur une tâche jusqu’à ce qu’elle soit terminée. Cela est idéal pour les tâches de longue durée qui ne nécessitent pas de supervision constante. Pour plus d’informations, consultez « Autoriser GitHub Copilot CLI à fonctionner de manière autonome ».

Si vous le souhaitez, vous pouvez généralement accélérer les tâches volumineuses en utilisant la /fleet commande slash au début de votre invite pour permettre à Copilot de découper la tâche en sous-tâches parallèles exécutées par des sous-agents. Pour plus d’informations, consultez « Exécution de tâches en parallèle avec la /fleet commande ».

7. Instructions d’équipe

Configuration recommandée du référentiel

```
        **Créer `.github/copilot-instructions.md`** Avec:
```
- Générer et tester des commandes
- Recommandations en matière de style de code
- Vérifications requises avant les validations
- Décisions relatives à l’architecture
```
        **Établissez des conventions** pour :
```
- Quand utiliser /plan (fonctionnalités complexes, refactorisation)
- Quand utiliser /delegate (travail tangentiel)
- Processus de révision du code avec assistance IA

Considérations relatives à la sécurité

        CLI Copilot nécessite une approbation explicite pour les opérations potentiellement destructrices.

Passez en revue toutes les modifications proposées avant d’accepter.
Utilisez des listes d’autorisation judicieusement.
Ne jamais commettre de secrets. Copilot est conçu pour éviter cela, mais toujours vérifier.

Mesure de la productivité

Suivez les métriques telles que :

Temps entre le problème et la demande de tirage
Nombre d’itérations avant fusion
Cycles de commentaires de révision du code
Améliorations apportées à la couverture des tests

Obtenir de l’aide

À partir de la ligne de commande, vous pouvez afficher de l’aide à l’aide de la commande : copilot -h.

Pour obtenir de l’aide sur différentes rubriques, entrez :

copilot help TOPIC

où TOPIC peut être l’un des suivants : config, , commands``environment, logging, ou permissions.

Dans l’interface en ligne de commande (CLI)

Pour obtenir de l’aide dans l’interface CLI, entrez :

/help

Pour afficher les statistiques d’utilisation, entrez :

/usage

Pour envoyer des commentaires privés à GitHub concernant CLI Copilot, déposer un rapport de bogue ou soumettre une demande de fonctionnalité, entrez :

/feedback

Travaux pratiques

Essayez l’exercice Création d’applications avec CLI Copilot Compétences pour une expérience pratique de création d’une application avec CLI Copilot.

Voici ce que vous allez apprendre :

Installer CLI Copilot
Utiliser le modèle de problème pour créer un problème
Générer une application de calculatrice d’interface de ligne de commande Node.js
Développer la fonctionnalité de calculatrice
Écrire des tests unitaires pour les fonctions de calculatrice
Créer, examiner et fusionner votre pull request

Lectures complémentaires

        [AUTOTITLE](/copilot/concepts/agents/about-copilot-cli)

        [AUTOTITLE](/copilot/how-tos/use-copilot-agents/use-copilot-cli)

        [AUTOTITLE](/copilot/reference/copilot-cli-reference/cli-command-reference)

        [
        Copilot plans et tarification](https://github.com/features/copilot/plans)

Bonnes pratiques pour l’interface CLI GitHub Copilot

Dans cet article