Aller au contenu
DevSecOps Logo DevSecOps
Docs
Blog

GitHub Copilot VS Code : prompts et instructions

Mise à jour :

logo copilot

Dans un précédent guide sur GitHub Copilot, nous avons exploré les bases de son intégration dans Visual Studio Code et comment l’utiliser pour assister l’écriture de code. Mais saviez-vous qu’il est possible d’aller bien plus loin que les simples suggestions en temps réel ?

Le chat de Copilot permet d’interagir de manière plus dynamique avec l’outil, en posant des questions ou en demandant des clarifications sur les suggestions proposées. Cela ouvre la porte à des échanges plus riches et à une personnalisation encore plus poussée.

Il est désormais possible de personnaliser en profondeur son comportement grâce à deux outils puissants : les instructions personnalisées et les **fichiers de prompt **. Ces mécanismes transforment Copilot en un véritable assistant de développement sur mesure, capable de respecter vos conventions, d’appliquer des règles de codage strictes, ou encore de générer automatiquement des composants entiers selon vos propres scénarios.

Dans ce guide, nous allons voir comment exploiter ces fonctionnalités pour piloter la création d’un projet d’API Python avec Flask, en imposant des normes précises et des tests automatisés dès la phase de génération.

Pourquoi utiliser instructions personnalisées et fichiers de prompt avec Copilot

Les suggestions automatiques de Copilot sont souvent pertinentes, mais elles peuvent manquer de cohérence lorsqu’on travaille sur des projets structurés avec des conventions strictes. C’est ici qu’interviennent les instructions personnalisées et les fichiers de prompt. Ces deux fonctionnalités permettent de guider Copilot de manière précise et contextuelle, bien au-delà des simples complétions basées sur l’historique du fichier courant.

Instructions personnalisées : standardiser le comportement global

Les instructions sont définies soit dans un fichier Markdown (copilot-instructions.md) placé dans le répertoire .github/, lui même se trouvant à la racine du projet. Elles servent à imposer des normes générales sur le style de code, la structure des commentaires, les frameworks à utiliser, les noms de fonctions, etc.

Elles permettent à Copilot de proposer du code aligné avec vos pratiques dès le premier jet. Par exemple :

---
applyTo: "**/*.py"
---
# Codestyle
- Utiliser snake_case pour toutes les fonctions.
- Préférer la syntaxe moderne de Python 3.10+.
- Structurer les tests dans un dossier `tests/` avec `pytest`.

Le fichier copilot-instructions.md peut être complété par d’autres fichiers d’instructions spécifiques à des modules ou des fonctionnalités. Pour cela, il suffit de créer de nouveaux fichiers Markdown dans le répertoire .github/instructions et les nommer de manière appropriée avec le suffixe .instructions.md.

Ex :

.github/instructions/tests.instructions.md
---
applyTo: "**/tests/**/*.py"
description: "Instructions pour les tests"
---


# Codestyle pour les tests


- Utiliser pytest et fixtures.
- Écrire des tests unitaires pour chaque fonction.
- Structurer les tests de manière logique (ex : tests par fonctionnalité).

Prompt files : automatiser des tâches spécifiques

Les prompts files sont des fichiers .md contenant des consignes très ciblées, à lancer manuellement depuis Copilot Chat dans VS Code. Ils permettent de déclencher une génération contrôlée de code à partir d’un scénario donné. Contrairement aux instructions globales, ils agissent comme des scripts de commande : initier une API, ajouter une route, générer des tests, etc.

Un prompt file est utile pour :

  • générer rapidement des squelettes de projet ;
  • automatiser des actions répétitives (ajout de routes, configuration, etc.) ;
  • garantir une uniformité sur plusieurs modules.

Exemple de prompt file :

.github/prompts/add_endpoint.prompt.md
---
description: "Ajouter un endpoint à l'API Flask"
---


# Ajouter un endpoint Flask


Créez un nouvel endpoint en suivant le style existant :


## À générer
- Route Flask avec GET/POST/PUT/DELETE
- Validation des données
- Gestion d'erreurs (404, 400)
- Test unitaire avec pytest


## Conventions
- Messages d'erreur en français
- Code PEP8 avec docstrings
- Réponses JSON formatées
- Type hints Python


Respectez l'architecture existante du projet.

Les prompts files doivent être placées dans le répertoire .github/prompts/ de votre projet et se nommer avec le suffixe .prompt.md (ex : init_api.prompt.md, etc.).

Premiers pas avec les instructions et prompt files Copilot

Dans le précédent guide, nous avons vu comment installer et configurer VS Code pour utiliser GitHub Copilot.

1. Activation des fonctionnalités

Ensuite, ouvrez votre fichier settings.json et ajoutez les options de configuration Copilot suivante :

{
  "github.copilot.chat.codeGeneration.useInstructionFiles": true,
  "github.copilot.chat.promptFiles": true,
  "github.copilot.enable": {
    "*": true,
    "yaml": true,
    "plaintext": false
  }
}

2. Créer le ou les fichiers d’instructions

Il est recommandé de créer un fichier copilot-instructions.md pour chaque projet afin de définir des directives spécifiques. Vous pouvez également créer des fichiers d’instructions supplémentaires pour des cas d’utilisation particuliers.

Commencez par créer un dossier .github/ à la racine du projet, puis ajoutez un fichier :

Terminal window
mkdir -p .github/instructions
touch .github/copilot-instructions.md

Ce fichier contiendra vos directives principales. Exemple de contenu pour un projet Python :

applyTo: "**/*"
description: "Configuration pour le projet"
---


# Instructions GitHub Copilot - API Rest Flask


Ce projet est une **API REST moderne** développée avec Flask pour la gestion d'une bibliothèque numérique. Il utilise une architecture modulaire simple et maintenable avec les technologies suivantes :


- **Framework** : Flask 3.0+ avec Flask-RESTful
- **Base de données** : SQLite (développement) / PostgreSQL (production) avec SQLAlchemy ORM
- **Validation** : Marshmallow pour la sérialisation/désérialisation
- **Tests** : Pytest avec fixtures et couverture de code
- **Documentation** : Flask-RESTX pour Swagger UI automatique
- **Déploiement** : Configuration Docker et scripts de démarrage


## 🏗️ Architecture du projet


### Structure des dossiers


```text
flask-api/
├── app/                           # Code source principal
│   ├── __init__.py                # Factory pattern Flask
│   ├── config.py                  # Configuration environnements
│   ├── models/                    # Modèles SQLAlchemy
│   ├── resources/                 # Contrôleurs API REST
│   ├── schemas/                   # Validation Marshmallow
│   └── utils/                     # Utilitaires
├── tests/                         # Tests unitaires et intégration
├── migrations/                    # Migrations base de données
├── docs/                          # Documentation API
└── pyproject.toml                 # Dépendances Python avec uv
```


## 🛠️ Conventions de développement


### Style de code


* **Python** : Respect strict de PEP8, docstrings détaillées
* **Imports** : Organisés par groupes (stdlib, tiers, locaux)
* **Variables** : snake_case pour variables et fonctions, CamelCase pour classes
* **Type hints** : Obligatoires pour toutes les fonctions publiques

Avec ce simple prompt, vous pouvez demander à Copilot de générer le squelette de l’application. Je peux vous garantir que vous serez abasourdi par la qualité du code généré.

3. Créer des fichiers de prompt pour les tâches récurrentes

Créez ensuite un sous-dossier :

Terminal window
mkdir .github/prompts/

Ajoutez des fichiers .prompt.md selon les cas d’usage. Par exemple :

generate-unit-test.prompt.md

---
description: "Générer un test unitaire"
---


- Écris un test unitaire pour la fonction sélectionnée.
Utilise pytest.
- Teste les cas normaux et les cas d’erreur.
- Ajoute des assertions explicites.

Validation et test des instructions

Une fois vos fichiers copilot-instructions.md et *.prompt.md créés, il est important de vérifier leur bon fonctionnement.

  1. Réouverture du projet : VS Code recharge automatiquement les instructions à l’ouverture du workspace.

  2. Vérification dans Copilot Chat : Lorsqu’une génération est influencée par un fichier d’instructions, l’onglet References du chat indique les règles appliquées.

  3. Test des prompt files :

    • Sélectionnez une fonction Python dans votre code.
    • Exécutez une commande via un prompt file, par exemple /generate-unit-test.
    • Vérifiez si les tests générés respectent vos conventions (Pytest, docstrings, assertions).

Astuce : Créez un prompt file review-code.prompt.md qui force Copilot à analyser une sélection de code pour vérifier si les conventions sont respectées.

---
description: "Revue de code Python"
---
- Vérifie le respect de PEP8.
- Vérifie l’utilisation de type hints.
- Vérifie la clarté des noms de variables et fonctions.
- Suggère des améliorations avec exemples concrets.

Résolution de problèmes courants

Si vous rencontrez des problèmes avec les instructions ou les prompts, voici quelques pistes à explorer :

  • Instructions non prises en compte :

    • Redémarrer VS Code
    • Vérifier l’emplacement de(s) fichier(s):
      • Le fichier principal copilot-instructions.md doit être dans .github/.
      • Les fichiers de sous-instructions doivent se trouver dans .github/instructions/.
    • Contrôler la syntaxe YAML

  • Prompts files non visibles :

    • Vérifier la configuration promptFiles: true
    • Les fichiers de prompts doivent se trouver dans .github/prompts/.
    • S’assurer du suffixe .prompt.md

Utilisation avancée des instructions et prompt files

Une fois les bases maîtrisées, vous pouvez aller plus loin et exploiter les instructions et prompt files comme de véritables briques de votre workflow de développement. L’idée est simple : transformer Copilot en un assistant contextuel qui connaît vos règles, applique vos conventions, et vous aide à automatiser des tâches parfois fastidieuses.

Organisation des fichiers d’instructions

Pour garder un projet maintenable, il est recommandé de structurer vos fichiers Markdown de manière claire :

Terminal window
.github/
├── copilot-instructions.md        # Instructions globales
├── instructions/
│   └── tests.instructions.md      # Normes spécifiques pour les tests
├── prompts/
│   ├── generate-unit-test.prompt.md
│   └── review-code.prompt.md
  • Les instructions globales se trouvent dans copilot-instructions.md.
  • Les instructions spécialisées sont placées dans .github/instructions/.
  • Les prompt files sont regroupés dans .github/prompts/.

Cette organisation permet de partager facilement vos standards au sein d’une équipe via Git, tout en évitant de mélanger des règles générales et spécifiques.

Modulariser vos instructions

Il est tentant de tout regrouper dans un unique fichier copilot-instructions.md. Mais en pratique, il est plus efficace de modulariser vos règles selon le contexte :

  • un fichier principal copilot-instructions.md pour les conventions globales ;
  • des fichiers spécialisés dans .github/instructions/ (par exemple tests.instructions.md pour les règles liées aux tests ou docs.instructions.md pour la documentation).

Grâce à l’option applyTo, vous pouvez cibler précisément où vos règles s’appliquent :

---
applyTo: "app/**/*.py"
description: "Instructions pour le code applicatif"
---
# Règles applicatives
- Respect strict de PEP8
- Utiliser SQLAlchemy pour la base de données
- Forcer l’usage de type hints

Ainsi, Copilot applique la bonne règle au bon endroit sans surcharge inutile.

Réutiliser et partager des prompt files

Les prompt files ne sont pas limités à un seul projet. Vous pouvez :

  • créer une bibliothèque de prompts réutilisables (par ex. generate-tests.prompt.md, review-code.prompt.md) ;
  • les partager dans plusieurs repositories pour que toute l’équipe adopte la même approche ;
  • centraliser ces fichiers dans un dépôt interne et les importer dans chaque projet.

Un prompt file peut aussi inclure d’autres fichiers Markdown. Cela permet de composer des prompts complexes à partir de blocs plus simples. Par exemple :

---
description: "Initialiser un projet Flask complet"
---
# Initialisation du projet


Inclure les conventions de :
- [./coding-rules.md](./coding-rules.md)
- [./tests-guidelines.md](./tests-guidelines.md)


## À générer
- Squelette Flask avec factory pattern
- Route /health
- Configuration Docker
- Tests unitaires avec Pytest

Hiérarchie et résolution des conflits

Il est important de comprendre la hiérarchie des règles dans Copilot :

  1. Instructions globales (copilot-instructions.md) s’appliquent à tout le projet.
  2. Instructions spécifiques (.github/instructions/*.instructions.md) prennent le relais sur certaines parties du code.
  3. Prompt files déclenchés manuellement viennent en dernier et guident la génération en fonction d’un besoin précis.

Cette hiérarchie permet d’éviter les contradictions et garantit que Copilot respecte toujours le bon niveau de directive.

Automatiser vos scénarios récurrents

Avec un peu de créativité, vous pouvez utiliser les prompt files pour automatiser des tâches entières :

  • Scaffolding de projet : un prompt file qui génère la structure complète d’une API, d’une application web ou d’un module Python.
  • Revue de code : un prompt review-code.prompt.md qui vérifie automatiquement la conformité à vos règles (PEP8, type hints, clarté des noms).
  • Sécurité : un prompt security-audit.prompt.md pour analyser une portion de code à la recherche de failles ou mauvaises pratiques.
  • Messages de commit : un prompt qui génère des messages conformes aux normes Conventional Commits.

Exemple pour une revue de code Python :

---
description: "Revue automatique de code"
---
- Vérifie la conformité PEP8
- Signale l’absence de type hints
- Détecte les noms de variables ambigus
- Propose des améliorations claires avec exemples

Bonnes pratiques à retenir

  • Restez concis : mieux vaut plusieurs fichiers courts et ciblés qu’un seul fichier massif.
  • Testez régulièrement vos instructions pour vérifier qu’elles influencent bien Copilot (onglet References dans Copilot Chat).
  • Partagez et versionnez vos fichiers dans Git pour les rendre accessibles à toute l’équipe.
  • Évoluez progressivement : commencez par des règles simples, puis raffinez au fil du temps.

Avec cette approche, Copilot devient un assistant de développement réellement intégré à vos pratiques d’équipe, et non plus seulement un outil de complétion automatique.

Conclusion

Les instructions personnalisées et les prompt files font de GitHub Copilot un véritable assistant de développement. En combinant :

  • des instructions modulaires pour standardiser le style de code et les pratiques projets,
  • des prompt files spécifiques pour automatiser des tâches récurrentes ou complexes,
  • et une architecture claire (global > spécifique > prompt) pour hiérarchiser les sources de contexte,

tu transformes ton workflow en un système prévisible, performant et toujours aligné avec tes conventions internes.

Pour aller encore plus loin :

  • Modularise tes instructions pour éviter la surcharge et maintenir la lisibilité.
  • Réutilise des prompt files bien pensés pour optimiser automatiquement la productivité.
  • Mesure la valeur ajoutée en observant la qualité du code généré, la conformité aux normes, et le temps gagné.

Ce modèle intelligent de configuration te permettra d’évoluer rapidement, d’adapter les pratiques à l’échelle de l’équipe et, surtout, de rendre Copilot indispensable à ton processus de développement.