L'Art du Prompt avec
GitHub Copilot

⚡ Quick Start — Résultats en 2 minutes

Pas le temps de tout lire ? Voici 3 prompts qui marchent immédiatement. Copiez-collez et adaptez.

1. Générer une fonction complète

Dans le Chat (Ctrl + Alt + I), tapez :

Copier → Chat
Crée une fonction TypeScript qui valide un email.
Paramètre : string. Retour : boolean.
Gère les cas : null, vide, format invalide, domaines jetables.
Inclus 5 tests unitaires avec Vitest.

2. Expliquer du code inconnu

Sélectionnez du code, puis Ctrl + I :

Copier → Inline Chat
Explique ce code ligne par ligne.
Niveau : comme si j'étais un dev junior.
Identifie les bugs potentiels.

3. Transformer du code existant

Sélectionnez du code, puis Ctrl + I :

Copier → Inline Chat
Refactore ce code :
- Remplace les callbacks par async/await
- Ajoute le typage TypeScript strict
- Ajoute la gestion d'erreurs

1 Les fondamentaux du prompting

Un prompt est une instruction donnée à l'IA. Avec Copilot, chaque commentaire, nom de fichier, ou message dans le chat est un prompt. Comprendre les principes de base transforme radicalement la qualité des suggestions.

Qu'est-ce qu'un prompt ?

Dans le contexte de GitHub Copilot, un prompt est l'ensemble des informations que l'IA reçoit pour générer du code. Cela inclut :

• Le fichier courant — tout le code déjà écrit au-dessus et en-dessous du curseur
• Les autres fichiers ouverts — Copilot utilise les onglets ouverts comme contexte
• Les commentaires — des instructions en langage naturel dans le code
• Les noms — noms de fonctions, variables, classes, fichiers
• Les messages dans le chat — vos questions et instructions directes

Les 5 principes cardinaux

2 Anatomie d'un bon prompt

Un prompt efficace a une structure reconnaissable. Comme une bonne recette, il contient des ingrédients précis dans un ordre logique.

La formule CITER

Pour structurer vos prompts, utilisez l'acronyme CITER :

Comparaison : prompt vague vs prompt structuré

// fais une fonction de login

// Contexte : API REST Express + TypeScript + PostgreSQL (via Prisma)
// Intention : Créer une fonction de login qui vérifie les credentials
// Format : Async/Await, retourner un objet { token, user } ou throw une erreur typée
// Exemple : Similaire à la fonction register() dans auth.service.ts
// Restrictions : Utiliser bcrypt pour le hash, JWT avec expiration 24h
// Ne pas stocker le mot de passe dans le token

async function login(email: string, password: string): Promise<AuthResponse> {

3 Techniques essentielles

Ces techniques forment la boîte à outils de base de tout utilisateur de Copilot. Maîtrisez-les et vous aurez déjà une longueur d'avance.

3.1 — Le commentaire directif

La technique la plus simple : écrire un commentaire décrivant ce que le code doit faire, puis laisser Copilot compléter.

Python
# Lire un fichier CSV, filtrer les lignes où le montant > 1000,
# regrouper par catégorie, et retourner un dict {catégorie: total}
def analyze_expenses(filepath: str) -> dict[str, float]:
    # Copilot complète ici...

3.2 — Le nommage intentionnel

Des noms de fonctions et variables descriptifs sont eux-mêmes des prompts puissants :

function process(data) {
function handle(x) {
const temp = getData();

function validateAndSanitizeUserEmail(rawInput: string): string {
function convertCelsiusToFahrenheit(celsius: number): number {
const activeUsersFromLastWeek = await fetchUsersByDateRange(lastWeek);

3.3 — Le typage comme prompt

En TypeScript ou Python (type hints), les types sont un langage que Copilot comprend parfaitement :

TypeScript
interface PaginatedResponse<T> {
  data: T[];
  total: number;
  page: number;
  perPage: number;
  hasNextPage: boolean;
}

// Rien qu'avec ce type, Copilot peut générer :
// - une fonction de pagination
// - un helper pour construire la réponse
// - des tests appropriés

3.4 — La technique du « premier exemple »

Donnez un premier exemple complet, et Copilot suivra le pattern pour les suivants :

JavaScript
// Mappings de codes d'erreur HTTP vers des messages utilisateur
const httpErrors = {
  400: { title: "Requête invalide", message: "Les données envoyées sont incorrectes.", icon: "⚠️" },
  401: { title: "Non autorisé", message: "Veuillez vous connecter.", icon: "🔒" },
  // Copilot va continuer avec 403, 404, 500, etc. en suivant exactement le même format
};

3.5 — Le prompt négatif (dire ce qu'on NE veut PAS)

Parfois, il est plus efficace de spécifier les contraintes négatives :

Prompt Chat
Crée un composant React de formulaire d'inscription.
- NE PAS utiliser de bibliothèque de formulaires (pas de Formik, react-hook-form)
- NE PAS utiliser de classes CSS (utiliser Tailwind)
- NE PAS stocker le mot de passe en clair
- NE PAS faire de validation côté client uniquement

3.6 — Le "tone" explicite

Trop souvent oublié : préciser le ton donne des résultats très différents :

3.7 — Le "thinking step"

Demandez à Copilot de penser à haute voix avant de coder :

Prompt Chat
Annonce d'abord ton approche, puis implémente.

Problème : Créer une fonction qui retourne le Nième nombre de Fibonacci
Optimisé pour les grandes valeurs de N.

Demandé :
1. « Approche 1 : récursion naïve (pourquoi c'est mauvais) »
2. « Approche 2 : mémoïsation (complexité, avantages) »
3. « Approche 3 : itérative (la meilleure ici, pourquoi) »
4. Puis l'implémentation de l'approche 3 en TypeScript

4 Maîtriser la complétion inline

La complétion inline (suggestions fantômes en gris) est le cœur de Copilot. Voici comment en tirer le maximum.

Les raccourcis essentiels

Stratégie : accepter partiellement

La technique la plus sous-estimée : accepter mot par mot avec Ctrl + →. Cela vous permet de :

• Prendre le début de la suggestion et modifier la suite
• Guider Copilot progressivement dans la bonne direction
• Garder le contrôle tout en bénéficiant de l'autocomplétion

Déclencher de meilleures suggestions inline

1. Ouvrez les fichiers pertinents — Copilot utilise les fichiers ouverts comme contexte
2. Écrivez la signature d'abord — types de paramètres, type de retour, puis laissez compléter le corps
3. Utilisez des imports explicites — ils indiquent à Copilot quelles bibliothèques utiliser
4. Écrivez un test d'abord (TDD) — Copilot lira votre test pour déduire l'implémentation

TDD avec Copilot
// 1. Écrivez le test d'abord :
test('slugify converts "Hello World" to "hello-world"', () => {
  expect(slugify("Hello World")).toBe("hello-world");
});
test('slugify removes special characters', () => {
  expect(slugify("Café & Résumé!")).toBe("cafe-resume");
});

// 2. Allez dans le fichier d'implémentation, écrivez :
function slugify(text: string): string {
  // Copilot a lu vos tests → complétion précise

5 Patterns de prompts réutilisables

Des formules éprouvées pour des cas d'usage courants. Copiez-les et adaptez-les à votre contexte.

Pattern 1 — Conversion / Transformation

Template
// Convertir [FORMAT_SOURCE] en [FORMAT_CIBLE]
// Input : [description de l'entrée avec exemple]
// Output : [description de la sortie avec exemple]
// Cas limites : [null, vide, caractères spéciaux...]

// Convertir une date ISO 8601 en format humain français
// Input : "2026-02-28T14:30:00Z"
// Output : "samedi 28 février 2026 à 15h30" (timezone Europe/Paris)
// Cas limites : string vide → "Date inconnue", date invalide → throw Error
function formatDateFR(isoDate: string): string {

Pattern 2 — CRUD / API

Template
// [VERBE HTTP] /api/[ressource]
// Auth : [requis/optionnel], rôles : [admin, user...]
// Body/Params : [schéma JSON]
// Réponse succès : [status + schéma]
// Erreurs : [liste des cas d'erreur]
// Validation : [règles métier]

Pattern 3 — Refactoring

Prompt Chat
Refactorise cette fonction en appliquant :
1. Principe de responsabilité unique (SRP)
2. Extraire les magic numbers en constantes nommées
3. Remplacer les conditions imbriquées par du early return
4. Ajouter le typage TypeScript strict
5. Garder la même API publique (ne pas casser les appelants)

Voici la fonction :
```
[coller le code]
```

Pattern 4 — Tests unitaires

Prompt Chat
Génère des tests unitaires pour la fonction [nom] dans [fichier].
Framework : [Jest / Vitest / pytest / etc.]
Couvrir :
- Le cas nominal (happy path)
- Les cas limites (valeurs vides, null, très grandes)
- Les cas d'erreur (input invalide, exceptions)
- Les cas de bord (concurrence, timeout si applicable)
Style : AAA (Arrange / Act / Assert), un seul assert par test.

Pattern 5 — Documentation

Prompt Chat
Génère la documentation JSDoc/docstring pour toutes les fonctions publiques de ce fichier.
Inclure :
- Description en une phrase
- @param avec type et description
- @returns avec type et description
- @throws si applicable
- @example avec un cas d'usage réaliste
Langue : français

Pattern 6 — Debug

Prompt Chat
Ce code produit [décrire le comportement observé].
Le comportement attendu est [décrire ce qui devrait se passer].
L'erreur ne se produit que quand [conditions de reproduction].

Environnement : [Node 20 / Chrome / Python 3.12...]
Dépendances concernées : [versions]

Voici le code :
```
[coller le code]
```

Voici l'erreur complète :
```
[coller le stack trace]
```

Pattern 7 — Architecture / Design Pattern

Prompt Chat
Concevoir une architecture pour [fonctionnalité].
Contraintes :
- Scalabilité : jusqu'à [X utilisateurs/requêtes par seconde]
- Stack : [langages/frameworks]
- Bdd : [type]
- Latence : < [Xms]

Fournir :
1. Diagramme d'architecture (Mermaid)
2. Détail de chaque composant
3. Points de goulot d'étranglement potentiels
4. Plan de scaling horizontal

Pattern 8 — Performance & Optimisation

Prompt Chat
Optimise ce code/cette requête pour la performance.
Métriques actuelles : [temps, RAM, requetes par seconde]
Objectif : [50% plus vite / -40% RAM...]

Limitations : [ne pas changer l'API, rester compatible]

Analyse :
1. Profil : où passe le temps ?
2. Goulots : qu'est-ce qui ralentit ?
3. Solutions : listées de la plus simple à la plus complexe
4. Trade-offs : qu'est-ce qu'on gagne/perd ?

Pattern 9 — Sécurité

Prompt Chat
Compléte ce code avec les bonnes pratiques de sécurité.
Contexte : [type d'appli, données sensibles]

Sécurité à ajouter :
- Validation d'entrée (whitelist/blacklist/sanitization)
- Gestion des secrets (pas en dur, utiliser env vars)
- Authentification / Autorisation
- Rate limiting / DDoS protection
- Cryptage (données en transit et au repos)
- Audit logging

Pattern 10 — Maintenance & Documentation

Prompt Chat
Dôtes ce code pour la maintenabilité.

Inclure :
- Comments en-ligne pour la brèque (pourquoi ce hack ?)
- Type hints / JSDoc complets
- Exemples d'usage
- Avertissements (deprecated, breaking change venir)
- Lien vers la documentation pertinente

6 Copilot Chat — Prompts conversationnels

Le Chat est votre partenaire de pair-programming. Apprenez à lui parler pour obtenir des réponses précises et exploitables.

Les Slash Commands

Copilot Chat reconnaît des commandes spéciales préfixées par / :

Les variables de contexte (#)

Utilisez # pour référencer du contexte spécifique :

/fix #problems

Corrige toutes les erreurs TypeScript dans #file:auth.service.ts
en tenant compte du schéma Prisma dans #file:schema.prisma

Stratégie de conversation

1. Premier message : posez le contexte global (« Je travaille sur une API de e-commerce en NestJS »)
2. Messages suivants : demandes précises, une à la fois
3. Si le résultat dérive : reformulez plutôt que de rajouter des couches de corrections
4. Nouvelle direction : n'hésitez pas à ouvrir un nouveau chat plutôt que de traîner un long historique pollué

7 Les Agents & Modes de Copilot

Depuis 2025, Copilot propose des modes spécialisés qui transforment fondamentalement la façon d'interagir avec l'IA.

Les 3 modes principaux

Le mode Agent en détail

Le mode Agent est le plus puissant. Il peut :

• Lire et modifier plusieurs fichiers simultanément
• Exécuter des commandes terminal (build, test, lint…)
• Détecter les erreurs de compilation et les corriger automatiquement
• Créer de nouveaux fichiers et dossiers
• Installer des packages et dépendances
• Itérer : si le build casse, il analyse l'erreur et corrige

Crée un système de notifications en temps réel pour notre app Next.js.

Stack actuelle :
- Next.js 14 (App Router) + TypeScript
- Prisma + PostgreSQL
- NextAuth pour l'authentification

Je veux :
1. Un modèle Prisma « Notification » (id, userId, type, message, read, createdAt)
2. Une API route POST /api/notifications pour créer
3. Une API route GET /api/notifications pour lister (avec pagination)
4. Un composant React NotificationBell avec badge de compteur
5. Utiliser Server-Sent Events (SSE) pour le temps réel
6. Des tests pour les API routes

Conventions du projet :
- Fichiers dans src/
- Composants dans src/components/
- API dans src/app/api/
- Services dans src/services/
- Style avec Tailwind CSS

Le fichier copilot-instructions.md

.github/copilot-instructions.md
# Instructions pour GitHub Copilot

## Stack technique
- Next.js 14 (App Router) + TypeScript strict
- Base de données : PostgreSQL via Prisma
- Authentification : NextAuth v5
- Style : Tailwind CSS + shadcn/ui
- Tests : Vitest + Testing Library

## Conventions de code
- Nommage : camelCase pour les variables, PascalCase pour les composants
- Fichiers : kebab-case (ex: user-service.ts)
- Un composant par fichier
- Utiliser les Server Components par défaut, 'use client' uniquement si nécessaire
- Toujours typer les props avec des interfaces (pas de `any`)
- Gestion d'erreurs : toujours utiliser des try/catch avec des types d'erreur personnalisés

## Structure du projet
src/
├── app/          # Routes et layouts Next.js
├── components/   # Composants réutilisables
├── services/     # Logique métier
├── lib/          # Utilitaires et configurations
├── types/        # Interfaces et types TypeScript
└── __tests__/    # Tests unitaires et d'intégration

## Règles métier
- Les prix sont toujours en centimes (integer)
- Les dates sont stockées en UTC
- Les emails sont normalisés en lowercase

8 Gestion du contexte

Le contexte est le carburant de Copilot. Plus le contexte est pertinent et ciblé, meilleures seront les suggestions. Mais attention : trop de contexte noie aussi l'IA.

La hiérarchie du contexte

Copilot priorise les sources de contexte dans cet ordre :

1. Le fichier courant — le code autour de votre curseur (le plus important)
2. Les fichiers ouverts (onglets) — Copilot les scanne comme contexte adjacent
3. Le fichier copilot-instructions.md — instructions permanentes
4. La sélection / #file — contexte explicitement fourni dans le Chat
5. L'indexation du workspace — recherche sémantique via #codebase

Stratégie des onglets ouverts

Avant de coder, ouvrez volontairement les fichiers pertinents :

Le fichier .copilotignore

Comme .gitignore, vous pouvez créer un fichier .copilotignore pour exclure certains fichiers du contexte :

.copilotignore
# Exclure les secrets et configs sensibles
.env
.env.*
**/secrets/**

# Exclure les fichiers générés volumineux
**/generated/**
**/dist/**
**/node_modules/**

# Exclure les données de test volumineuses
**/__fixtures__/**/*.json

9 Techniques avancées

Pour ceux qui veulent aller au-delà des bases. Ces techniques demandent de la pratique mais transforment complètement la productivité.

9.1 — Le pseudo-code comme prompt

Écrivez en pseudo-code ou en français structuré, puis demandez la traduction :

Pseudo-code → Code réel
// ALGORITHME : Système de retry avec backoff exponentiel
// 1. Tenter l'appel
// 2. Si échec ET tentatives < MAX_RETRIES :
//    a. Calculer délai = BASE_DELAY * 2^tentative + random jitter
//    b. Attendre le délai
//    c. Retour à l'étape 1
// 3. Si toutes les tentatives échouent : throw dernière erreur
// 4. Sinon : retourner le résultat
//
// Contraintes : timeout global de 30s, log chaque retry

async function fetchWithRetry<T>(url: string, options?: RequestInit): Promise<T> {

9.2 — Chain of Thought (raisonnement pas à pas)

Demandez à Copilot de raisonner avant de coder :

J'ai un problème de performance sur cette requête Prisma qui met 8 secondes.

Avant de proposer une solution :
1. Analyse la requête et identifie les N+1 potentiels
2. Liste les index manquants probables
3. Propose un plan d'optimisation, du plus simple au plus complexe
4. Implémente chaque étape

Requête problématique :
```typescript
const orders = await prisma.order.findMany({
  include: {
    user: true,
    items: { include: { product: { include: { category: true } } } },
    shipping: true,
  },
  where: { createdAt: { gte: lastMonth } },
  orderBy: { createdAt: 'desc' },
});
```

9.3 — Le multi-fichier coordonné

Pour les changements qui touchent plusieurs fichiers, donnez une vue d'ensemble :

Prompt Agent
Ajoute un système de « favoris » à l'application.
Voici tous les fichiers à modifier/créer :

1. prisma/schema.prisma → Ajouter modèle Favorite (userId, productId, createdAt)
2. src/services/favorite.service.ts → CRUD des favoris
3. src/app/api/favorites/route.ts → API GET (liste) et POST (toggle)
4. src/components/FavoriteButton.tsx → Bouton cœur avec état optimiste
5. src/hooks/useFavorites.ts → Hook React Query pour les favoris
6. src/__tests__/favorite.service.test.ts → Tests du service

Assure-toi que chaque fichier est cohérent avec les autres.
Le toggle doit être atomique (pas de double favori possible).

9.4 — Le prompt de review

Prompt Chat
Fais une code review de #changes (les modifications Git en cours).

Vérifie :
- 🔒 Sécurité (injections, failles XSS, secrets exposés)
- 🐛 Bugs potentiels (null checks, race conditions, edge cases)
- ⚡ Performance (boucles inutiles, requêtes N+1, memory leaks)
- 📖 Lisibilité (nommage, complexité cyclomatique, code mort)
- 🧪 Testabilité (le code est-il testable ? tests manquants ?)

Format de réponse :
🔴 Critique — à corriger avant merge
🟡 Important — à considérer fortement
🟢 Suggestion — amélioration optionnelle

9.5 — Custom Instructions par contexte

VS Code permet d'avoir des fichiers d'instructions à différents niveaux :

Structure
mon-projet/
├── .github/
│   └── copilot-instructions.md     ← Instructions globales
├── .vscode/
│   └── settings.json               ← Paramètres Copilot spécifiques
├── frontend/
│   └── .copilot-instructions.md    ← Instructions pour le frontend
└── backend/
    └── .copilot-instructions.md    ← Instructions pour le backend

10 Les 10 erreurs les plus fréquentes

Même les utilisateurs expérimentés tombent dans ces pièges. Connaître les erreurs courantes est la première étape pour les éviter.

❌ 1. Le prompt « fais tout »

Crée-moi une application complète de e-commerce avec authentification,
panier, paiement Stripe, gestion des stocks, tableau de bord admin,
notifications email, et déploiement Docker.

Solution : Décomposez en 10-15 tâches atomiques et traitez-les une par une.

❌ 2. Ne pas vérifier le code généré

Copilot est un assistant, pas un développeur senior infaillible. Lisez toujours le code avant d'accepter, surtout pour :

• La sécurité (validation d'entrées, injections SQL, secrets en dur)
• La logique métier critique (calculs financiers, permissions)
• Les dépendances (packages obsolètes ou vulnérables)

❌ 3. Ignorer le contexte des onglets

Vous demandez de générer un service mais le seul onglet ouvert est un fichier CSS. Copilot manque de contexte et invente.

❌ 4. Des prompts trop longs dans le chat

Un prompt de 500 lignes est contre-productif. L'IA perd le fil. Restez sous 50 lignes pour le chat, découpez sinon.

❌ 5. Oublier de spécifier le langage/framework

Crée une fonction pour lire un fichier JSON

En Python 3.12, crée une fonction async qui lit un fichier JSON
avec gestion d'erreurs (FileNotFoundError, JSONDecodeError)
et retourne un dict typé avec TypedDict.

❌ 6. Accepter Tab aveuglément

Prenez l'habitude de lire la suggestion fantôme avant d'appuyer sur Tab. Un mauvais nom de variable ou une logique inversée se glisse facilement.

❌ 7. Combattre l'IA au lieu de la guider

Si Copilot s'obstine dans une mauvaise direction après 3 essais, c'est que votre contexte le mène là. Changez d'approche :

• Reformulez complètement le prompt
• Ouvrez un nouveau chat
• Ajoutez ou retirez du contexte (#file)
• Écrivez le début du code souhaité manuel pour guider

❌ 8. Ignorer les instructions du workspace

Ne pas utiliser copilot-instructions.md quand vous travaillez en équipe, c'est comme ne pas écrire de README. Vos collègues auront des suggestions incohérentes.

❌ 9. Utiliser le mauvais mode

❌ 10. Ne pas itérer

Le prompt parfait du premier coup est rare. Le workflow optimal est :

1. Prompt initial → résultat ~70%
2. « Modifie X et Y » → résultat ~85%
3. « Aussi, gère le cas Z » → résultat ~95%
4. Ajustement manuel des 5% restants

11 Recettes prêtes à l'emploi

Copiez-collez ces prompts directement dans Copilot Chat. Adaptez les mots entre [crochets] à votre contexte.

🏗️ Scaffolding de projet

Copilot Chat — Mode Agent
Initialise un projet [framework] avec :
- TypeScript strict (strictNullChecks, noImplicitAny)
- ESLint + Prettier configurés
- Structure de dossiers selon les conventions [framework]
- Un fichier .env.example avec les variables requises
- Un README.md avec les instructions d'installation
- Un Dockerfile multi-stage pour la production
- Un .github/copilot-instructions.md décrivant le projet

🔐 Audit de sécurité

Copilot Chat
Fais un audit de sécurité de #codebase en vérifiant :
1. Injections SQL / NoSQL (requêtes construites par concaténation)
2. XSS (données utilisateur rendues sans échappement)
3. CSRF (routes POST/PUT/DELETE sans token)
4. Secrets en dur (clés API, mots de passe dans le code)
5. Dépendances vulnérables (check package.json)
6. Validation d'entrées manquante (API routes)
7. Contrôle d'accès (routes sans vérification d'auth)

Pour chaque problème trouvé, donne :
- Le fichier et la ligne
- La sévérité (critique / haute / moyenne / basse)
- Le fix recommandé avec du code

📊 Analyse et explication de code

Copilot Chat
Analyse #file:[fichier] et génère :
1. Un résumé en une phrase de ce que fait ce fichier
2. Un diagramme Mermaid du flux de données
3. La liste des dépendances externes utilisées
4. Les points d'amélioration potentiels (performance, lisibilité, maintenabilité)
5. Un score de complexité estimé (simple / modéré / complexe / très complexe)

🔄 Migration de code

Copilot Chat — Mode Agent
Migre [ce code/ce fichier/ce module] de [techno source] vers [techno cible].

Règles de migration :
- Conserver la même logique métier
- Adapter les idiomes au style de [techno cible]
- Gérer les cas où il n'y a pas d'équivalent direct
- Ajouter des commentaires "// MIGRATION:" pour les choix non évidents
- Mettre à jour les imports et dépendances
- Créer/adapter les tests

📝 Commit messages

Copilot Chat
Génère un message de commit Conventional Commits pour #changes.

Format : type(scope): description concise

Types : feat, fix, refactor, docs, test, chore, perf, style
- Première ligne : max 72 caractères
- Corps : expliquer le POURQUOI (pas le quoi)
- Footer : référencer les issues si applicable

🧪 Matrice de tests

Copilot Chat
Pour la fonction [nom] dans #file:[fichier], génère une matrice de tests :

| Cas | Input | Output attendu | Catégorie |
|-----|-------|-----------------|-----------|
| ... | ...   | ...             | nominal/limite/erreur |

Puis implémente chaque cas en [framework de test].
Utilise des describe() imbriqués pour organiser par catégorie.

12 Mémo : raccourcis clavier VS Code

Tous les raccourcis Copilot essentiels en un seul endroit.

13 Configurer Copilot pour de meilleurs résultats

Un Copilot bien configuré produit de meilleurs résultats dès le premier prompt. Voici les réglages essentiels.

Le fichier copilot-instructions.md

Créez un fichier .github/copilot-instructions.md à la racine de votre projet. Copilot le lira automatiquement pour personnaliser ses réponses :

.github/copilot-instructions.md
# Instructions pour Copilot

## Stack technique
- Language : TypeScript strict (no any)
- Runtime : Node.js 20 LTS
- Framework : Express.js avec architecture en couches
- ORM : Prisma avec PostgreSQL
- Tests : Vitest + Supertest
- Linting : ESLint + Prettier (config Airbnb)

## Conventions de code
- Noms de variables/fonctions : camelCase
- Noms de classes/types : PascalCase
- Noms de fichiers : kebab-case (user-service.ts)
- Exports : named exports (pas de default export)
- Fonctions : arrow functions préférées sauf pour les classes
- Max 30 lignes par fonction
- Toujours utiliser des interfaces, jamais `type` pour les objets

## Patterns à suivre
- Error handling : classes d'erreurs custom (AppError, NotFoundError, etc.)
- Validation : Zod schemas pour toutes les entrées
- Logging : pino avec context structuré
- Responses : format normalisé { success, data, errors, meta }

## À éviter
- `any` → utiliser `unknown` + type guard
- `console.log` → utiliser le logger
- Callbacks → async/await
- `var` → `const` / `let`
- Classes de plus de 200 lignes

Settings VS Code essentiels

settings.json
{
  // Choix du modèle (selon votre abonnement)
  "github.copilot.chat.models": ["gpt-4o", "claude-sonnet-4"],

  // Suggestions inline
  "github.copilot.enable": {
    "*": true,
    "markdown": true,
    "plaintext": false  // Désactiver pour les textes non-code
  },

  // Chat : toujours inclure les instructions
  "github.copilot.chat.useProjectInstructions": true,

  // Nombre max de completions proposées
  "github.copilot.advanced": {
    "inlineSuggest.count": 3
  },

  // Copilot comme code action par défaut
  "editor.codeActionsOnSave": {
    "source.fixAll.copilot": "explicit"
  }
}

Choisir le bon modèle

Fichiers de prompts réutilisables

Créez un dossier .prompts/ dans votre projet avec des templates de prompts standardisés :

Structure recommandée
.prompts/
├── review.md        # Template de code review
├── test.md          # Template de génération de tests
├── refactor.md      # Template de refactoring
├── doc.md           # Template de documentation
└── debug.md         # Template de debug

Utilisation dans le Chat :
"Fais une review de #file:src/service.ts en suivant #file:.prompts/review.md"

👁️ 14. Prompting multi-modal

GitHub Copilot et ChatGPT évoluent vers le multi-modal : images, captures d'écran, diagrammes. Voici comment en tirer parti.

🖼️ Copilot Vision — Analyser des images

Copilot Chat dans VS Code peut analyser des images que vous collez directement dans le chat. Cas d'usage :

• Screenshot d'une erreur → collez l'image et demandez « Explique cette erreur et propose un fix »
• Maquette UI → collez un wireframe et demandez « Génère le HTML/CSS correspondant »
• Diagramme d'architecture → collez le schéma et demandez « Implémente cette architecture en code »
• Tableau de données → collez un screenshot Excel et demandez « Convertis en JSON »

[Coller screenshot de la maquette]

Génère le composant React correspondant à cette maquette.
Utilise Tailwind CSS pour le styling.
Respecte exactement la disposition, les couleurs et les espacements visibles.

[Coller screenshot du bug dans le navigateur]

Mon application affiche ce rendu incorrect. Le header devrait être fixe
et la sidebar devrait avoir un scroll indépendant.
Analyse le screenshot et propose les corrections CSS nécessaires.

📊 Diagrammes et documentation visuelle

Exploitez le multi-modal pour automatiser la documentation :

🎯 Bonnes pratiques multi-modal

✦ En résumé

Le prompt engineering avec Copilot n'est pas une science exacte — c'est un art itératif. Voici les clés à retenir :