Patrice Eon for Onepoint

Posted on Dec 23

Guide d'apprentissage pour maîtriser GitHub Copilot

#programming #ai #githubcopilot #adventoftech2025

GitHub Copilot est le nouvel allié des développeurs pour coder plus vite et plus intelligemment.

Mais soyons honnêtes : la plupart d'entre nous l'utilisent comme une simple autocomplétion augmentée.

Résultat ? On exploite à peine 20 % de sa véritable puissance. C'est un peu comme avoir une Ferrari et ne jamais dépasser la deuxième vitesse.

En effet en 2025, GitHub Copilot a pris du muscle. Fini l'assistant timide qui suggère trois lignes de code. Place à un partenaire IA complet, dopé aux modèles de pointe (Claude Sonnet 4.5, GPT-5, Gemini 3 Pro). Il comprend désormais votre code dans son ensemble, orchestre des tâches complexes en autonomie et s'intègre parfaitement à votre écosystème de développement.

Ce guide existe pour une raison simple : vous faire passer de 20 % à 100 % d'utilisation. Grâce à 10 techniques éprouvées et des protocoles avancés, vous découvrirez comment transformer Copilot d'un simple assistant en copilote stratégique.

Parce qu'au final, l'objectif n'est pas juste de coder plus vite. C'est de coder plus intelligemment, en laissant l'IA gérer la vitesse pendant que vous vous concentrez sur ce qui compte vraiment : l'intelligence de vos solutions.

Table des matières

Partie I : Installation et présentation des fondamentaux (démarrage en douceur)
Partie II : Maîtriser les leviers de productivité
Partie III : Écosystème et Agenticité Avancée
Partie IV : Qualité, sécurité et rôle humain (Les Pièges)
Conclusion : Codez plus Intelligemment, pas seulement plus vite

Partie I : Installation et présentation des fondamentaux (démarrage en douceur)

Cette partie couvre l'installation, les accès, et la compréhension des modes d'interaction avec Github Copilot.

1.1 GitHub Copilot dans votre IDE vs GitHub Copilot CLI 🖊️

GitHub Copilot se déploie sur deux fronts stratégiques : directement intégré à votre IDE préféré (VS Code, IntelliJ...) pour une assistance en temps réel, et en ligne de commande pour orchestrer vos workflows depuis le terminal.

GitHub Copilot dans votre IDE

Fonctionnalités :

Complétion de code en temps réel (ligne ou fonction complète)
Copilot Chat intégré pour poser des questions ou générer des snippets
Intégration IDE : coloration, prévisualisation, acceptation avec Tab
Support multi-langages : Python, Java, JS, C++, Go, etc.

Usage typique :

Saisie de code et suggestions automatiques
Idéal pour une assistance immédiate et interactive dans l’éditeur

GitHub Copilot CLI

Fonctionnalités :

Assistant IA dans le terminal, indépendant de l’éditeur
Exploration de projet (fichiers, dépendances, structure)
Génération et modification de code via prompts en langage naturel
Exécution de commandes shell suggérées (avec confirmation)
Refactoring et workflows multi-étapes automatisés

Usage typique :

Travailler depuis le terminal, générer ou corriger du code
Idéal pour workflows scriptables ou projets distants

Comparaison rapide

Fonctionnalité	Copilot VS Code	Copilot CLI
Suggestions inline de code	✅ Oui	❌ Non
Chat intégré	✅ Oui	❌ Terminal-style
Modification de fichiers	✅ Oui	✅ Oui
Exécution commandes shell	❌	✅ Oui
Analyse globale du projet	Limité	✅ Oui
Indépendant de l’éditeur	❌	✅ Oui
Automatisation & workflows complexes	Moyen	✅ Oui

Résumé : VS Code pour coder efficacement au quotidien, CLI pour gérer et transformer des projets depuis le terminal.

1.2 Installer GitHub Copilot sur VS Code 🧩

La documentation officielle pour installer GitHub Copilot dans VS Code se trouve ici : Copilot VS Code extension

Ouvrir VS Code
Aller dans la Marketplace des extensions (Ctrl+Shift+X ou Cmd+Shift+X sur Mac)
Rechercher GitHub Copilot
Cliquer sur Installer
Se connecter à GitHub quand demandé (OAuth)
Les suggestions apparaissent automatiquement
Pour activer/désactiver : Ctrl+Shift+P / Cmd+Shift+P → taper Copilot → Enable/Disable GitHub Copilot

Astuce :

Configurer les suggestions dans Fichier → Préférences → Paramètres → GitHub Copilot

Fonctionne avec Python, Java, JS, C++, Go, etc.

1.3 Installer GitHub Copilot sur IntelliJ IDEA 🧩

La documentation officielle pour installer GitHub Copilot dans IntelliJ (mais également les autres IDE supporté) se trouve ici : Copilot Jetbrains extension

Ouvrir IntelliJ IDEA
Aller dans File → Settings → Plugins (Preferences → Plugins sur Mac)
Cliquer sur Marketplace, chercher GitHub Copilot
Cliquer sur Installer
Redémarrer IntelliJ
Se connecter à GitHub pour activer Copilot
Les suggestions apparaissent automatiquement lors de la saisie de code

Astuce :

Activer/désactiver : Settings → GitHub Copilot
Utilisable aussi dans le terminal intégré pour générer des snippets

1.4 Obtenir un compte GitHub avec accès Copilot 📝

Étape 1 : Créer un compte GitHub

Aller sur https://github.com/join
Remplir le formulaire (nom d’utilisateur, email, mot de passe)
Confirmer votre email

Étape 2 : Activer GitHub Copilot

Option	Type d’abonnement	Coût	Étapes
A	Free	0$	1. Aller sur https://github.com/features/copilot 2. Cliquer sur Free 3. Suivre l’activation
B	Pro	~10$/mois ou 100$/an	Aller sur https://github.com/settings/billing → entrer les informations de paiement
C	Pro+	~39$/mois ou 390$/an	Aller sur https://github.com/settings/billing → entrer les informations de paiement

Alternative : Abonnement Etudiant (gratuit)

Aller sur GitHub Student Developer Pack

Étape 3 : Vérifier l’accès

Aller sur https://github.com/features/copilot
Vérifier le message “You have access” ou la période d’essai en cours
Installer l’extension dans VS Code ou IntelliJ et commencer à coder

1.5 Installer GitHub Copilot CLI 🚀

GitHub Copilot CLI, permet de déléguer une tâche à l'IA directement dans votre terminal — exit l'éditeur de code.

Pourquoi l'installer maintenant ? Parce que l'usage agentique avancé (détaillé plus loin dans ce guide) repose sur cette base.

Prérequis

Un compte GitHub avec accès à Copilot activé (voir section précédente)
Node.js version 20 ou supérieure installé

Étapes d'installation

Ouvrir votre terminal
Installer l'extension GitHub CLI si ce n'est pas déjà fait :

# Sur macOS/Linux avec Homebrew
brew install gh

# Sur Windows avec winget
winget install --id GitHub.cli

Se connecter à GitHub :

gh auth login

Installer l'extension Copilot CLI :

gh extension install github/gh-copilot

Vérifier l'installation :

gh copilot --version

Utilisation basique

Une fois installé, vous pouvez utiliser Copilot directement dans le terminal :

# Demander de l'aide sur une commande
gh copilot suggest "comment lister tous les fichiers modifiés dans les 7 derniers jours"

# Expliquer une commande complexe
gh copilot explain "git rebase -i HEAD~3"

Astuce :

La documentation complète est disponible sur : GitHub Copilot CLI Documentation
Utilisez gh copilot --help pour voir toutes les commandes disponibles

1.6 GitHub Copilot dans votre IDE : Aperçu des contrôles et fonctionnalités 🎛️

N’utiliser qu’un prompt basique (comme ci‑dessous) sans exploiter les autres fonctionnalités utiles de GitHub Copilot peut sembler assez limitant.

C’est pourquoi je partage une collection d’astuces pratiques; vous en reconnaîtrez certaines, mais j’espère que quelques‑unes vous inspireront à tirer pleinement parti de ce que Copilot peut offrir.

1.6.1 Les contrôles du panneau de chat

Configurer un nouveau contexte pour vos prompts. Utile pour repartir à zéro sur des tâches non liées.
Réouvrir les contextes de prompts historiques utilisés auparavant. Utile pour basculer entre différents contextes.
Générer des fichiers de prompt, des instructions, etc. (voir la section Meta Prompting ci‑dessous)
Options supplémentaires de configuration de la fenêtre de chat (prompt)
Maximiser votre fenêtre de chat (prompt)
Masquer votre fenêtre de chat (prompt)

1.6.2 Modes Agent, Ask, Edit, Plan et Configure

Choisissez comment vous voulez que GitHub Copilot vous aide. Dans beaucoup de cas, vous utiliserez simplement l’Agent. Difficile de voir pourquoi on aurait encore besoin de Ask ou Edit une fois qu’on a l’Agent, utilisé pour notre Vibe Programming !

En réalité, ces trois modes répondent à des intentions différentes :

Ask est le mode conversation et compréhension. Il sert à poser des questions, demander des explications, explorer une API, comprendre un bout de code ou valider une approche sans modifier votre code. C’est idéal pour réfléchir, apprendre ou lever un doute rapidement.
Edit est le mode chirurgical. Vous sélectionnez du code et demandez une transformation précise : refactoriser, renommer, optimiser, traduire un commentaire, corriger un bug local. Copilot agit uniquement sur la zone ciblée, sans initiative au-delà de ce que vous avez demandé. Parfait quand vous voulez garder un contrôle strict.
Agent est le mode autonome et orienté objectif. Vous lui donnez une intention globale (« ajoute l’authentification », « implémente cette feature », « corrige les tests cassés ») et il explore le projet, crée ou modifie plusieurs fichiers, exécute des actions et itère. C’est le compagnon idéal pour le Vibe Programming, quand vous voulez avancer vite et laisser Copilot prendre des décisions.

👉 En résumé :

Ask = comprendre et discuter
Edit = modifier précisément
Agent = déléguer et construire

Les trois sont complémentaires : Agent pour aller vite, Edit pour ajuster, Ask pour comprendre.

Passer par Configure custum Agents est utile pour fournir de meilleures instructions à l’agent afin de permettre des prompts plus puissants. Vous pouvez en savoir plus loin dans l’article.

1.6.3 Sélection des modèles LLM

Sélectionnez le modèle LLM que vous souhaitez utiliser. Certains modèles sont meilleurs que d’autres. D’après mon expérience, Claude Sonnet est plus pertinent que GPT.

Mais attention, l’utilisation des modèles est limitée par le quota de requêtes indiqué par 0x, 1x et 3x. Ce sont des multiplicateurs appliqués à votre quota de requêtes premium.

0x : utilisation illimitée
1x : exactement votre quota de requêtes
3x : 3× votre quota de requêtes

Donc, utilisez‑les avec parcimonie selon vos besoins.

Le mode Agent de GitHub Copilot est devenu l’un des meilleurs agents de code depuis quelques mois.
Il peut analyser votre projet entier, traiter des issues GitHub, rédiger des pull requests, et même aider à écrire des tests.

Quel modèle fonctionne réellement le mieux en mode Agent de Copilot ?

Gemini 3 Pro : Le débogueur UI

Gemini 3 Pro de Google apportent quelque chose d’unique : un véritable raisonnement multimodal.

Cela signifie qu’il peut comprendre code, texte, images et même diagrammes en une seule passe.

Idéal pour :

Débogage UI ou visuel
Analyse code + documents
Pipelines de données en entreprise

Avantages :

✅ Excellent pour le raisonnement visuel
✅ Rapide, économique et scalable
✅ Excelle dans le traitement parallèle et l’orchestration d’outils

Inconvénients :

❌ Donne parfois des solutions génériques pour des tâches générales.
❌ Moins « réfléchi » que Claude pour le raisonnement profond.

GPT-5 : Le penseur profond

Si votre travail implique du raisonnement multi-étapes, du débogage complexe ou une analyse au niveau de l’architecture, GPT-5 brille — mais il faut bien l’instruire avec des prompts. Ses capacités d’analyse surpassent de nombreux autres modèles, et il peut résoudre des bugs complexes tout en offrant une vue d’ensemble plus claire du scénario.

Idéal pour :

Gros refactorings multi-fichiers
Raisonnement et débogage profonds
Projets nécessitant une compréhension contextuelle longue

Avantages :

✅ Très fort en raisonnement logique
✅ Gère texte + vision (excellent pour les diffs UI et captures d’écran [pas encore testé])
✅ Modes de raisonnement contrôlables

Inconvénients :

❌ Plus lent que les modèles légers.
❌ Moins économique pour les petits projets

Vous vous sentez bloqué ? Revenez au point de départ et expliquez tout le cas d’usage. Boom — c’est probablement le meilleur modèle pour résoudre ces casse-têtes. Un peu lent, mais efficace.

Claude Sonnet 4.5 : Le polyvalent raffiné

S’il y a un modèle qui se rapproche le plus d’un ingénieur senior, c’est Claude Sonnet 4.5.

Développé par Anthropic, Claude est reconnu pour sa clarté, sa fiabilité et sa capacité à gérer des immenses bases de code — jusqu’à 1 million de tokens.

Idéal pour :

Dépôts de niveau entreprise
Tâches autonomes de plusieurs heures
Sorties sûres et à faible hallucination

Avantages :

✅ Gère d’énormes fenêtres de contexte
✅ Excellent pour les grands monorepos et les refactorings
✅ Faible taux d’hallucination et ton cohérent

Inconvénients :

❌ Limité par le débit sur les configurations gratuites ou partagées
❌ Tarification légèrement premium

Avis personnel :

Claude Sonnet génère généralement un code plus propre et plus fiable que les autres. Mais quand vous atteignez les limites de débit, c’est frustrant — surtout lors de longues sessions.

Astuce : Pour des agents longue durée (comme des migrations de données ou des audits de dépôt), Claude Sonnet 4.5 est le choix le plus sûr.

1.6.4 Tableau de bord d’utilisation de Copilot

Vous pouvez voir combien vous avez utilisé de requêtes premium ce mois‑ci. Avec un abonnement PRO payant, vous avez un quota mensuel de 300 requêtes.

Notez que l’allocation est réinitialisée le premier du mois prochain.

1.6.5 Contrôle de l’activité des prompts

C’est ici que vous lancez le prompt ou l’arrêtez (s’il tourne)
Après la réponse, vous pouvez garder les changements effectués par l’agent ou les annuler.
Pour certaines étapes, il demandera votre permission avant d’agir (ex. exécuter une appli, installer, supprimer un fichier, etc.). Vous pouvez aussi le configurer pour toujours autoriser.

1.6.6 Fichier de contexte pour l’agent

Vous pouvez limiter votre agent à un contexte spécifique, qui peut être :

Un fichier ouvert
Une partie du fichier ouvert (comme sur le schéma ci‑dessus, de la ligne 11 à 16)
Ou joindre un nouveau fichier (ex. une image que l’agent lira, puis codera)
Utiliser # pour indiquer un fichier d’intérêt, @ pour accéder à l’extension et / pour accéder à une commande ou un fichier de prompt.

1.6.7 Gestion de code (Source Control)

Vous pouvez effectuer la gestion de code directement depuis VS Code.

Accéder à Source Control. S’il n’y en a pas, un bouton permet de l’initialiser ici
Ajouter (au contrôle de source), retirer ou ouvrir les fichiers modifiés
Écrire votre message de commit ici, ou utiliser l’IA (bouton étoile) pour le générer
Valider vos changements ajoutés, et choisir Amend, Push ou Sync avec le commit.

1.6.8 Paramètres de l’extension GitHub Copilot

Ouvrir le panneau des Extensions
Sélectionner les paramètres de Copilot
Vous pouvez maintenant activer l’autocomplétion pour le Markdown ou le texte brut !!

Partie II : Maîtriser les leviers de productivité

Cette section est le cœur du guide, détaillant les stratégies pratiques pour améliorer la précision et l'efficacité.

2.1 Maîtriser les commandes Slash

Les slash commandes sont des raccourcis intégrés qui évitent des prompts interminables. Tapez / dans Copilot Chat pour débloquer une productivité instantanée.

Slash Commands essentielles :

/tests — Génère des tests unitaires complets pour le code sélectionné, avec cas limites et mocks
/fix — Analyse les erreurs et propose des correctifs (null checks, refactors)
/explain — Explique des snippets de code complexes
/doc — Génère des commentaires de documentation pour fonctions et classes
/refactor — Suggère des améliorations et optimisations de code

Astuce : Combinez /tests avec #file:src/service.ts pour générer des tests spécifiques au service sans boilerplate.

Pourquoi c’est important : Ces commandes fonctionnent en chat et en inline (Alt+/) et sont incluses dans l’offre basique. Commencez par /tests et /fix — des gains rapides pour tout codebase.

Impact réel : Sur ce projet e‑commerce, /tests m’a à lui seul économisé 8 à 10 heures d’écriture de tests manuels sur tous les services.

Note gratuit vs payant : la version gratuite limite vos requêtes mensuelles. En gratuit, je me cognais les limites en plein projet. D’où mon passage à l’abonnement payant (10 $/mois individuel). Si vous utilisez Copilot au quotidien, le payant vaut le coup rien que pour l’illimité.

2.2 Utiliser les Variables de Contexte 📦

Copilot n’est pas devin. Plus vous lui donnez de contexte, mieux il vous aide.

Variables de contexte puissantes :

#file — Référencez des fichiers précis : #file:auth.service.ts
#codebase — Laissez Copilot fouiller toute votre base de code
#editor — Ajoute tous les fichiers ouverts au contexte
@workspace — Posez des questions sur toute la structure du projet
#fetch — Récupère du contenu web ou de la doc

Exemple en action :

@workspace Sur notre serveur Node, quelles optimisations pour gérer 10 000 requêtes concurrentes ?

Astuce : surlignez le code pertinent avant de questionner. Copilot donne alors des suggestions ciblées et évite les suppositions.

2.3 Créer des instructions personnalisées ✍️

Pour arrêtez de vous battre avec les suggestions : Définir les standards de codage de l'équipe (style, conventions, utilisation de const vs var) dans le fichier .instructions.md,. L'objectif est de garantir une cohérence permanente du code généré.

Configurer les instructions personnalisées :

Lancez Chat: New Instructions File depuis la palette de commandes
Cela crée .instructions.md dans le dossier .github/instructions
Définissez vos règles projet en Markdown

Exemple de fichier d’instructions :

Custom instructions for Copilot

Project Context
This project is a React + Node.js e-commerce platform

Code Style
- Use TypeScript strict mode
- Prefer functional components with hooks
- Use camelCase for variables
- Write descriptive variable names (no single letters)

Testing
- Use Jest for unit tests
- Use Playwright for E2E tests
- Always include error handling tests

Indentation
We use 2 spaces, not tabs

Pourquoi ça marche : Copilot génère désormais du code conforme à VOTRE style, pas des patterns génériques. Temps d’édition réduit jusqu’à 40 %.

2.4 Stratégie d'ouverture de fichiers 📂

Petit secret : Copilot ne voit pas les fichiers fermés. Ouvrir 3 à 5 fichiers liés lui donne un contexte massif sur la structure.

Stratégie d’ouverture maligne :

Avant d’écrire du nouveau code, ouvrez :

Le fichier que vous éditez
Les utilitaires/helpers liés
Les fichiers de types
Les fichiers de config
Des implémentations similaires existantes

Exemple : écrire un nouvel endpoint API ? Ouvrez :

routes/user.routes.ts (là où vous travaillez)
controllers/user.controller.ts (patterns existants)
models/User.ts (structure de données)
middleware/auth.ts (contexte d'authentification)

Rappel critique : fermez les fichiers hors sujet quand vous changez de tâche. Trop de fichiers non liés perturbent le contexte.

2.5 Commenter le Flux de travail 🗨️

Écrire des commentaires détaillés spécifiant l'architecture, le flux, le traitement des erreurs et les cas limites AVANT d'écrire le code. Cette planification augmente significativement la précision de la sortie de l'IA.

// Objectif : Auth JWT + refresh tokens + reset password sécurisé
// Flux : signup -> email verify -> login -> refresh -> logout
// Exigences : rate limiting, CSRF, rotation de refresh tokens, IP logging
// Cas limites : token expiré, utilisateur désactivé, tentative brute force

Voyez Copilot comme un dev junior. Plus vos consignes sont claires, meilleur est le résultat.

Workflow « comment-first »

Plutôt que plonger direct dans le code, écrivez en tête de fichier un commentaire descriptif expliquant l’architecture et le flux.

Résultat : Copilot génère un code qui suit vos spécifications, incluant la gestion d’erreurs et les cas limites.

Astuce : incluez des exemples d’entrées/sorties dans les commentaires. La précision des suggestions augmente fortement.

2.6 Le Dialogue itératif 🔄

Ne pas accepter la première suggestion. Affiner les résultats par des follow-up prompts spécifiques pour garantir la validation côté client ou l'ajout de logique manquante.

Gros morceau en 2025. Copilot CLI intègre Claude Sonnet 4.5 — et ce modèle est bluffant en code.

Fonctionnalités CLI puissantes :

/model — Changez de modèle IA à la volée
Exécution directe du shell avec le préfixe !
Support image via mentions @
Permissions d’outils améliorées avec des glob patterns

Exemple concret :

# Générer des commandes terminal complexes
gh copilot explain "How do I find all .js files modified in the last 7 days and run eslint on them?"

# Exécuter directement !
npm run test:unit

Astuce : utilisez la commande /usage pour suivre les requêtes premium et optimiser votre flux.

2.7 Fichiers de prompts personnalisés 🗃️

Créer des modèles réutilisables pour des requêtes complexes dans votre projet (.github/prompts/).

Le mode Agent permet à Copilot de travailler de façon autonome — trouver des fichiers, éditer du code, et décider sans saisie constante.

Quand utiliser le mode Agent :

Refactorings sur de grandes bases de code
Conversion entre frameworks
Implémentation de fonctionnalités à travers plusieurs fichiers
Débogage d’issues complexes

Comment activer :

Ctrl+Shift+Alt+L (Windows) ou Cmd+Shift+Alt+L (Mac)
Ou /agent dans le chat

Exemple de prompt :

Commande GitHub Copilot dans mon espace réel

@workspace Objectif :
Créer une page web statique qui présente une estimation des résultats du FC Nantes (FCN) pour la fin de saison de Ligue 1.

Contraintes générales :
Page web en HTML, CSS et JavaScript vanilla
Design moderne, lisible et responsive

Couleurs officielles du FC Nantes :
Jaune : #FFD700
Vert : #006A3D

Typographie sportive et élégante
Aucun framework externe

Note de sécurité : le mode Agent requiert votre validation avant exécution des changements. Relisez tout attentivement.

2.8 Glisser-Déposer de Contexte 🖱️

Contexte Visuel et Logistique : déposer des fichiers, des logs d'erreurs, des dossiers, et même des captures d'écran directement dans Copilot Chat pour une analyse immédiate. Utiliser le fichier package.json pour informer l'IA des dépendances.

Par ailleurs vous connaissez ce moment où vous êtes « dans la zone » et ne voulez pas changer de fenêtre ? L’inline chat est fait pour ça.

Raccourcis inline chat (je cherchais où l’ouvrir dans VS Code jusqu’à trouver ces raccourcis) :

Ctrl+I / Cmd+I — Démarrer le chat inline directement dans l’éditeur
Alt+/ — Accès rapide aux slash commands en inline

Cas parfaits :

Petites corrections en debug
Générer une fonction unique
Ajouter de la gestion d’erreurs à du code existant
Refactoriser un bloc précis

Workflow pro : surlignez le code problématique → Ctrl+I → tapez /fix → acceptez la suggestion → continuez à coder.

2.9 Stratégie de nettoyage de contexte 🧹

Supprimer les questions non pertinentes ou démarrer un nouveau fil de conversation pour éviter que l'historique ne dilue la qualité de la réponse (améliore la qualité de 30 %).

Sauvez vos meilleurs prompts et partagez‑les avec l’équipe. Les fichiers de prompt sont des templates réutilisables pour les tâches courantes.

Créer des fichiers de prompt :

Chat: New Prompt File via la palette
Enregistrez dans .github/prompts/
Écrivez le prompt en Markdown avec métadonnées

Exemple de fichier (.prompt.md) :

mode: 'agent'
tools: ['githubRepo', 'search/codebase']
description: 'Generate a new React component'
Your goal is to generate a new React component based on templates in #githubRepo yourcompany/design-system.
Requirements:
* Use TypeScript with strict types
* Follow design system patterns
* Include PropTypes
* Add Storybook story
* Include unit tests with React Testing Library

Utilisation : tapez /your-prompt-name dans le chat.

Bénéfice équipe : tout le monde suit les mêmes bonnes pratiques. Fini les styles incohérents.

2.10 Maîtriser la sélection de Code 🔍

Utiliser @selection ou mettre en surbrillance un bloc de code précis avant de poser une question afin d'obtenir des suggestions plus rapides et plus pertinentes.

Par ailleurs la fonction la plus simple mais sous‑utilisée : glissez des fichiers directement dans Copilot Chat.

Ce que vous pouvez glisser :

Plusieurs fichiers à la fois
Des dossiers entiers
Des captures et images (NOUVEAU en 2025 !)
Des logs d’erreurs du terminal
Des sorties d’échecs de tests

Cas puissant — rapport de bug :

Prenez une capture du bug UI
Glissez la capture dans Copilot Chat
Tapez : « Crée un rapport de bug pour ce problème de rendu »
Copilot analyse l’image et génère une documentation de bug détaillée

Astuce avancée : glissez votre package.json pour aider Copilot à comprendre vos dépendances et proposer du code compatible.

BONUS : stratégie « supprimer et redémarrer »

Copilot utilise l’historique de conversation comme contexte. S’il donne des réponses hors sujet :

Supprimez les anciennes questions non pertinentes
Démarrez un nouveau thread via le bouton +
Utilisez les flèches haut/bas pour naviguer dans l’historique (comme dans le terminal)

Cela garde la conversation ciblée et améliore la qualité des réponses d’environ 30 %.

Check‑list de gains rapides pour cette semaine

Avant de fermer cet article, engagez‑vous à tester ces trois points :

Ajoutez un fichier .instructions.md dans le répertoire instructions à la racine de votre projet principal, avec votre style de code
Installez Copilot CLI et essayez la commande /model avec Claude Sonnet 4.5
Ouvrez 4 à 5 fichiers liés la prochaine fois que vous écrivez du nouveau code et regardez les suggestions s’améliorer

2.11 Créer des issues à partir de captures d’écran 📸

Vous avez un rapport de bug avec une capture d’écran ? Ne l’écrivez pas manuellement, laissez Copilot s’en charger. Voici comment :

Prenez une capture d’écran du bug (par ex., une icône mal alignée ou un problème de mise en page)
Glissez-la dans la discussion Copilot sur github.com/copilot.
Ajoutez une consigne comme :

Crée un nouveau ticket en utilisant le label 'bug'. Utilise cette capture et décris l’icône de flèche qui se chevauche. Applique le modèle de ticket UI de ce dépôt.

Copilot lit l’image, génère un titre et une description clairs, applique les bons labels et utilise les modèles de tickets de votre dépôt. C’est plus rapide qu’une transcription manuelle et il repère souvent des détails que je pourrais manquer.

Astuce : Copilot peut déduire le contexte du ticket à partir de votre capture et de votre consigne ; pas besoin de tout expliciter.

2.12 Utiliser Github Copilot partout… Mais tirer le meilleur du plugin dans VS Code 🌐

Vous pouvez profiter de Github Copilot dans de nombreux IDE tels que Visual Studio Code, JetBrains, Visual Studio, Eclipse, XCode, Vim ou même Neovim.

L’idée est de garder votre environnement familier tout en bénéficiant des fonctionnalités de Github Copilot.

Néanmoins, les plugins VS Code pour Github Copilot sont souvent plus avancés et mis à jour plus fréquemment que pour les autres IDE.

Astuce : installez les plugins VS Code compatibles avec votre IDE préféré, et installez également VS Code en parallèle. Vous profitez ainsi du confort de votre environnement habituel tout en accédant facilement aux dernières nouveautés disponibles dans VS Code.

Partie III : Écosystème et Agenticité Avancée

Cette partie explore l'interopérabilité et les outils de niveau professionnel qui étendent Copilot au-delà de l'IDE.

3.1 Le Protocole de contexte Modèle (MCP) 🚀

Le MCP (Model Context Protocol) est un protocole d'interopérabilité — un peu comme un « USB-C pour les intégrations d'IA » — conçu pour étendre les capacités des modèles d’IA et leur permettre de se connecter de manière sécurisée et structurée à des outils, données et services externes.

Concrètement avec un MCP : L’IA peut accéder à des données réelles, appeler vos APIs, lire vos fichiers ou agir sur vos outils, selon des règles explicites.

Il existe plus de 30 intégrations MCP officielles, couvrant des domaines comme :

GitHub MCP propose un hub central pour la découverte et l'installation de serveurs MCP de partenaires (Figma, Postman, Terraform) Github hub central mcp server.

Intégration/Produit	Type	Résumé	Cas d'usage rapides
Conversion fichiers → Markdown	Utilitaire/Conversion	Convertir PDF, Word, Excel, images, audio en Markdown.	Markdown depuis PDF/Doc
GitHub (assistants IA)	DevOps	Gérer dépôts, issues, PR, workflows en langage naturel.	Gérer issues/PR
Chrome DevTools	DevTools	Serveur MCP pour Chrome DevTools.	Inspecter runtime
Notion (officiel)	Productivité	Serveur MCP officiel pour l’API Notion.	Notes/DB Notion
Azure MCP Tools	Cloud Integrations	Outils Azure MCP pour connecter agents IA et services Azure.	Azure services
Terraform (HCP/Enterprise)	IaC	Générer Terraform plus précis et automatiser workflows.	Infra as Code
Azure DevOps	DevOps	Dépôts, work items, builds, releases, tests, recherche de code.	Repos/CI/CD
Elasticsearch	Recherche/Analytics	Requêtes de recherche, mappings, ES	QL, shards via NL.
Hugging Face	IA/Modèles	Accéder modèles, datasets, Spaces, articles, collections.	Modèles/datasets
Jira + Confluence (remote)	Collaboration IT	Connexion sécurisée Jira/Confluence avec LLM/IDE/plateformes d’agents.	ITSM/Confluence

Expérimenter avec GitHub MCP

Je vous encourage à essayer GitHub MCP par vous-même. Voici comment configurer un serveur MCP localement :
setup github mcp server.

Une fois que GitHub MCP est lancé, vous pouvez le solliciter et l’utiliser.

Dans mon cas, je veux ajouter un nouvel élément de technologie à https://github.com/GoogleCloudPlatform/Template.

Le prompt que j’utilise est le suivant :

Use the GitHub MCP.
Refers to https://github.com/GoogleCloudPlatform/Template,
- Reads the contribution.md, and
- Create a technology item for Perplexity LLM Model, and
- Make a unique branch for the new Technology Item and
- Open a git issue and pull request

Il va alors utiliser Get File, Create Branch, Update File, Open Issue, Open Pull Request, et effectuer toutes les tâches nécessaires disponibles dans MCP Server : GitHub.

Personnellement, j’interagis beaucoup avec les MCP suivants :

Azure DevOps MCP : Voir les éléments de travail, mettre à jour le statut des tâches (ex. : passer à "Code Review"), gérer les PR sans quitter VS Code, réduisant la commutation de contexte.

Agent de Codage Teams : Déléguer des tâches à l'Agent via @GitHub dans Microsoft Teams, qui exécute la tâche sur le dépôt et crée automatiquement une Pull Request.

Chrome DevTools MCP : Utiliser l'Agent pour analyser la performance web (Largest Contentful Paint (LCP), Interaction to Next Paint (INP)) sur n'importe quelle URL.

3.2 🚀 Qu’est‑ce que « Awesome GitHub Copilot » ? 📡

Ce dépôt fournit une boîte à outils complète pour enrichir GitHub Copilot avec :

👉 Awesome Agents — Agents GitHub Copilot spécialisés qui s’intègrent aux serveurs MCP pour offrir des capacités étendues pour des workflows et outils spécifiques
👉 Awesome Prompts — Prompts ciblés et spécifiques à une tâche pour générer du code, de la documentation et résoudre des problèmes précis
👉 Awesome Instructions — Normes de codage et bonnes pratiques exhaustives applicables à des motifs de fichiers ou à des projets entiers
👉 Awesome Collections — Collections organisées de prompts, d’instructions et de modes de chat autour de thèmes et workflows spécifiques

🎯 Pourquoi utiliser « Awesome GitHub Copilot » ?

Productivité : des agents, prompts et instructions préconstruits font gagner du temps et assurent des résultats cohérents.
Bonnes pratiques : bénéficiez de normes et patterns de codage sélectionnés par la communauté.
Assistance spécialisée : accédez à des conseils de niveau expert via des agents personnalisés spécialisés.
Apprentissage continu : restez à jour sur les derniers patterns et pratiques à travers les technologies.

📖 Structure du dépôt

Structure du dépôt Awesome

├── prompts/          # Prompts spécifiques aux tâches (.prompt.md)
├── instructions/     # Normes de codage et bonnes pratiques (.instructions.md)
├── agents/           # Personas IA et modes spécialisés (.agent.md)
├── collections/      # Collections organisées d’éléments liés (.collection.yml)
└── scripts/          # Scripts utilitaires pour la maintenance

🎯 Comment utiliser les ressources « Awesome GitHub Copilot » ?

🤖 Agents personnalisés

Les agents personnalisés peuvent être utilisés dans Copilot Coding Agent (CCA), VS Code et Copilot CLI. Pour le CCA, lors de l’assignation d’un ticket à Copilot, sélectionnez l’agent personnalisé dans la liste fournie. Dans VS Code, vous pouvez activer l’agent personnalisé dans la session des agents, aux côtés des agents intégrés comme Plan et Agent.

🎯 Prompts

Utilisez la commande / dans GitHub Copilot Chat pour accéder aux prompts :

/awesome-copilot create-readme

📋 Instructions

Les instructions s’appliquent automatiquement aux fichiers selon leurs motifs et fournissent des conseils contextuels sur les normes de codage, les frameworks et les bonnes pratiques.

3.3 Custom agents 🤖

Un custom agent est un assistant IA personnalisé dans VS Code qui adopte une personnalité et un comportement spécifiques pour des tâches de développement précises. Par exemple, vous pouvez créer des agents pour :

Un planificateur de projet
Un réviseur de code sécurisé
Un architecte de solutions
Un testeur automatique

Chaque agent possède ses propres instructions, outils disponibles et comportements.

Pourquoi utiliser des Custom Agents ?

Spécialisation des tâches

Différentes tâches nécessitent différentes capacités. Un agent de planification peut n'avoir accès qu'à des outils de lecture pour éviter les modifications accidentelles, tandis qu'un agent d'implémentation aura tous les outils d'édition.

Instructions personnalisées

Chaque agent peut avoir des instructions spécifiques qui définissent comment l'IA doit fonctionner, garantissant des réponses cohérentes et adaptées à chaque fois.

Structure d'un fichier Custom Agent

Les custom agents sont définis dans des fichiers .agent.md (Markdown) avec cette structure :

En-tête (YAML frontmatter)

---
description: Générer un plan d'implémentation pour de nouvelles fonctionnalités
name: Planificateur
tools: ['fetch', 'githubRepo', 'search']
model: Claude Sonnet 4
handoffs:
  - label: Implémenter le plan
    agent: implementation
    prompt: Implémente le plan ci-dessus
    send: false
---

Champs disponibles :

description : Description brève de l'agent
name : Nom de l'agent
tools : Liste des outils disponibles
model : Modèle IA à utiliser
handoffs : Transitions suggérées vers d'autres agents

Corps du fichier

Le corps contient les instructions en Markdown qui guident le comportement de l'agent.

Créer un Custom Agent

Étape 1 : Créer le fichier

Ouvrez la liste des agents dans le Chat
Sélectionnez Configure Custom Agents
Cliquez sur Create new custom agent
Choisissez l'emplacement :
- Workspace : dans .github/agents (uniquement pour ce projet)
- User profile : pour tous vos projets

Étape 2 : Définir l'agent

Remplissez le fichier .agent.md :

---
description: Génère un plan d'implémentation détaillé
name: Plan
tools: ['search', 'fetch', 'githubRepo']
---

# Instructions de planification

Tu es en mode planification. Ta tâche est de générer un plan d'implémentation 
pour une nouvelle fonctionnalité.

Le plan doit inclure :
- Vue d'ensemble
- Exigences
- Étapes d'implémentation
- Tests nécessaires

Ne fais aucune modification de code, génère uniquement un plan.

Les Handoffs : enchaîner les agents

Les handoffs permettent de créer des workflows guidés entre agents avec des boutons de transition.

Exemple de workflow :

Planification → Implémentation : Générer un plan puis coder
Implémentation → Révision : Coder puis vérifier la qualité
Tests échouants → Tests réussis : Écrire les tests puis l'implémentation

handoffs:
  - label: Commencer l'implémentation
    agent: implementation
    prompt: Implémente maintenant le plan ci-dessus.
    send: false

label : Texte du bouton
agent : Agent cible
prompt : Texte à envoyer
send : Envoyer automatiquement (true/false)

Outils disponibles

Vous pouvez spécifier quels outils sont accessibles à chaque agent :

Outils VS Code intégrés : 'search', 'fetch', 'githubRepo'
Outils MCP : tous les outils d'un serveur avec 'nom-serveur/*'
Outils d'extensions

Exemple complet

---
description: Agent de révision de code se concentrant sur la sécurité
name: Réviseur Sécurité
tools: ['search', 'fetch']
model: Claude Sonnet 4
handoffs:
  - label: Corriger les problèmes
    agent: implementation
    prompt: Corrige les problèmes de sécurité identifiés ci-dessus.
---

# Instructions de révision sécurité

Tu es un expert en sécurité applicative. Analyse le code pour :

1. **Vulnérabilités de sécurité**
   - Injections SQL
   - XSS
   - CSRF
   - Fuites de données sensibles

2. **Bonnes pratiques**
   - Validation des entrées
   - Gestion des erreurs
   - Principe du moindre privilège

Pour chaque problème trouvé, fournis :
- Description claire
- Niveau de gravité
- Suggestion de correction

Partager les Custom Agents

Au niveau de l'équipe

Placez les fichiers dans .github/agents de votre workspace.

Au niveau de l'organisation

Les agents peuvent être définis au niveau GitHub Organization pour être disponibles dans tous les projets. Activez l'option dans les paramètres :

github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents

Conseils pratiques

Commencez simple : Créez d'abord des agents avec des rôles clairs
Limitez les outils : Donnez uniquement les outils nécessaires à chaque agent
Instructions précises : Plus les instructions sont claires, meilleurs sont les résultats
Utilisez les handoffs : Créez des workflows fluides entre agents
Testez et itérez : Affinez vos agents au fil de l'utilisation

3.4 Maîtriser le GitHub Copilot CLI 🚀

La GitHub Copilot CLI apporte les capacités IA de Copilot directement dans votre ligne de commande.

Plutôt que de jongler entre votre IDE et votre navigateur, vous pouvez faire appel à Copilot directement dans votre terminal pour les cas d'usage suivants :

Assistant IA dans le terminal, indépendant de l’éditeur
Exploration du projet (fichiers, dépendances, structure)
Génération et modification de code via des prompts en langage naturel
Exécution de commandes shell suggérées (avec confirmation)
Refactoring et automatisation de workflows multi-étapes

Vous pouvez utiliser Copilot CLI de deux manières :

Mode interactif (mode par défaut) : démarrez une session avec la commande copilot et conversez en aller‑retour, en affinant les tâches au fil de l’eau.
Mode programmatique : pour des prompts ponctuels. Passez une requête directement avec -p ou --prompt, et Copilot répond en ligne. Pour les tâches impliquant la modification ou l’exécution de fichiers, vous pouvez activer les options d’approbation pour garder les choses sûres et cohérentes.

Par exemple, vous pouvez demander :

copilot "create a bash script to check for uncommitted changes and push if clean"

ou bien en mode programmatique :

copilot -p "create a bash script to check for uncommitted changes and push if clean"

Copilot CLI écrira le script, expliquera ce qu’il fait, et vous demandera de confirmer avant de l’exécuter.

Copilot CLI demandera par défaut toujours une confirmation avant de lire, modifier ou exécuter des fichiers. Vous gardez ainsi donc le contrôle de votre environnement. (Note : Exception si vous choisissez « Yes, and remember this folder for future sessions » ou « Yes, and approve TOOL for the rest of the session » lorsque c’est demandé—Copilot suivra alors ces instructions au lieu de vous reposer la question. Plus de détails dans notre kit de démarrage ci‑dessous !)

Vous pouvez sélectionner l’une de ces options :

Yes, proceed : Copilot peut accéder et utiliser les fichiers de cet emplacement uniquement pour cette session.
Yes, and remember this folder for future sessions : les fichiers de ce dossier sont approuvés pour les sessions en cours et futures. En démarrant Copilot CLI depuis ce dossier, cette question ne vous sera plus posée (ne choisissez cette option que si vous êtes sûr qu’il sera toujours sans risque pour Copilot de travailler avec ces fichiers).
No, exit (Esc) : mettre fin à votre session Copilot CLI.

Cas d’usage de GitHub Copilot CLI, refactoring et automatisation de workflows multi-étapes avec un agent

L’option --allow-all-tools dans GitHub Copilot CLI permet d'autoriser Copilot à utiliser automatiquement tous les outils disponibles sur votre système, sans vous demander confirmation à chaque fois.

Exemple :

copilot --allow-all-tools -p "create a bash script to check for uncommitted changes and push if clean"

Partie IV : Qualité, sécurité et rôle humain (Les pièges à éviter)

Cette section est dédiée à la responsabilité du développeur et aux erreurs critiques à éviter ⚠️.

4.1 Prendre les suggestions de Copilot pour des vérités 🤖

L’erreur : Beaucoup de développeurs acceptent les suggestions de Copilot sans double vérification ✅❌.
Pourquoi c’est un problème : Le code généré par IA peut sembler correct mais contenir des bugs subtils 🐛, des problèmes de performance ⚡ ou des patterns obsolètes 📉.
Correctif : Traitez la sortie de Copilot comme des extraits Stack Overflow : relisez, testez et refactorisez avant de committer ✍️. Demandez-vous toujours : « Est-ce que j’écrirais ceci si Copilot ne me l’avait pas suggéré ? »

4.2 Ignorer la sécurité du code 🔒

L’erreur : Copilot peut générer du code non sécurisé (ex. requêtes SQL sans paramétrage, regex dangereuses, gestion faible des mots de passe).
Pourquoi c’est un problème : L’IA ne priorise pas intrinsèquement les bonnes pratiques de sécurité 🚨. Copier-coller aveuglément peut conduire à des vulnérabilités.
Correctif : Appliquez les pratiques de codage sécurisé : validez les entrées ✅, échappez les requêtes 🛡️, nettoyez les sorties ✨. Lancez une analyse statique (ex. SonarQube, plugins de sécurité ESLint) sur le code généré par Copilot.

4.3 Utiliser Copilot comme béquille pour les fondamentaux 🏗️

L’erreur : S’appuyer sur Copilot au lieu de comprendre le langage ou le framework sous-jacent 📚.
Pourquoi c’est un problème : Si vous ne savez pas pourquoi le code fonctionne, vous aurez du mal à le déboguer 🔍 ou l’étendre plus tard.
Correctif : Utilisez Copilot comme assistant d’apprentissage 🎓, pas comme substitut. Après avoir accepté une suggestion, faites une pause et expliquez-la (à vous-même ou en commentaire) avant de continuer.

4.4 Surcompliquer des solutions simples ✂️

L’erreur : Copilot génère parfois des solutions verbeuses pour des problèmes qui pourraient être résolus en une ligne 📝.
Pourquoi c’est un problème : La sur-ingénierie alourdit votre codebase ⚖️ et rend la maintenance plus difficile.
Correctif : Gardez le jugement du développeur dans la boucle 👨‍💻. Si la suggestion semble trop longue, demandez-vous s’il existe une solution plus élégante. Less is more.

4.5 Ne pas fournir de contexte pour de meilleures suggestions 🗂️

L’erreur : Écrire des noms de fonctions ou des commentaires vagues, puis s’attendre à ce que Copilot « sache » ce que vous voulez.
Pourquoi c’est un problème : L’IA se nourrit de contexte. Sans contexte, les suggestions peuvent être hors sujet ou déroutantes ❓.
Correctif : Rédigez des signatures de fonctions, commentaires et docstrings clairs ✏️. Exemple : au lieu de function processData(), utilisez function normalizeUserInput(userData: string[]): string[].

4.6 Ne pas garder Copilot dans le bon scope 🎯

L’erreur : Utiliser Copilot dans de grands fichiers encombrés sans contexte guide 🗃️.
Pourquoi c’est un problème : Copilot puise le contexte dans le code proche. Si votre fichier est chaotique, les suggestions deviennent moins précises ⚠️.
Correctif : Refactorez en modules plus petits et ciblés 🧩. Plus votre code est propre, plus Copilot devient pertinent.

4.7 Zapper les tests parce que « Copilot l’a écrit » 🧪

L’erreur : Supposer que la sortie de Copilot n’a pas besoin d’être testée en profondeur.
Pourquoi c’est un problème : Les suggestions de l’IA peuvent introduire des cas limites que vous n’aviez pas anticipés 🚫.
Correctif : Écrivez des tests unitaires, des tests d’intégration et des vérifications de cas limites pour tout code généré par Copilot. Bonus : Utilisez Copilot lui-même pour rédiger des cas de test — puis affinez-les manuellement 🛠️.

Conclusion : Codez plus intelligemment, pas seulement plus vite

GitHub Copilot n’est plus une autocomplétion ✨ : c’est un partenaire de développement capable d’orchestrer des tâches, d’analyser votre codebase et de s’intégrer à vos outils.

En combinant les fondamentaux (IDE vs CLI), les leviers de précision (slash commands, contexte, instructions, sélection) et l'agentique avancée (mode Agent 🤖, MCP 🧩, agents personnalisés 🛠️), vous passez de « coder plus vite » à « livrer mieux, avec maîtrise ».

La clé reste humaine 🧠 : cadrer le besoin, donner le bon contexte, et garder un œil critique sur la qualité, la sécurité et les tests.

En 2026, la différence viendra de ceux qui standardisent, automatisent et mesurent.

Plan d’actions immédiates

.instructions.md : formalisez vos normes d’équipe pour des sorties cohérentes.
/tests et /fix : sécurisez la qualité dès le flux quotidien.
Commentaire‑d’abord : décrivez architecture et cas limites avant de coder.
Contexte ciblé : ouvrez 3–5 fichiers pertinents, fermez le reste.
Copilot CLI : installez‑le et utilisez‑le pour scripts, issues et PR.
1 agent personnalisé : « Réviseur Sécurité » ou « Planificateur » + un handoff simple.

Cap sur 2026 : standardisez, automatisez, mesurez. Faites de Copilot votre accélérateur — et de vos pratiques, votre avantage.