Créer des invites effectives pour GitHub Copilot

  • 8 minutes

Une invite de commande est une instruction en langage naturel qui indique à GitHub Copilot ce que vous souhaitez qu'il fasse. Les messages peuvent être utilisés pour poser des questions, communiquer des requêtes ou décrire des tâches.

Par exemple, les instructions suivantes représentent une question, une demande et une description de tâche.

Question: How do I create a button that submits a form?

Request: Add a button that opens a modal dialog. The button should be blue with rounded corners.

Task: Build a product page that displays a product title, product image, product description, and price. Product information should be fetched from the attached ProductsList.json file. The price should be formatted as currency. The page should also include a button to add the product to the cart.

La qualité de votre instruction affecte directement la qualité de la réponse de GitHub Copilot.

Qu’est-ce qui caractérise une bonne requête ?

Créer des instructions de haute qualité est essentiel pour tirer le meilleur parti de GitHub Copilot. Les stratégies suivantes vous aideront à créer des invites qui génèrent des réponses plus précises, pertinentes et utiles.

Commencer de manière générale, puis préciser

Lorsque vous écrivez une invite pour Copilot, commencez par une description générale de votre objectif ou scénario, puis fournissez des exigences spécifiques. Cette approche donne à Copilot le contexte nécessaire tout en veillant à ce que vos besoins détaillés soient traités.

Example:

Write a function that tells me if a number is prime.

The function should take an integer and return true if the integer is prime.

The function should error if the input is not a positive integer.

Fournir des exemples concrets

Les exemples sont l'une des manières les plus efficaces de communiquer votre intention à Copilot. Vous pouvez fournir des exemples de données d’entrée, des sorties attendues et même des exemples d’implémentations pour guider la compréhension de l’IA.

Example:

Write a function that finds all dates in a string and returns them in an array. Dates can be formatted like:

- 05/02/24
- 05/02/2024
- 5/2/24
- 5/2/2024
- 05-02-24
- 05-02-2024
- 5-2-24
- 5-2-2024

Example usage:
findDates("I have a dentist appointment on 11/14/2023 and book club on 12-1-23")

Expected return: ["11/14/2023", "12-1-23"]

Interrompre les tâches complexes en étapes plus simples

Lorsque vous faites face à une tâche complexe ou volumineuse, décomposez-la en composants plus petits et gérables. Cette approche aboutit à de meilleurs résultats et facilite le débogage et l’amélioration des pièces individuelles.

Exemple : Au lieu de demander à Copilot de générer un puzzle complet de recherche de mots, décomposez-le :

  1. Write a function to generate a 10 by 10 grid of letters
  2. Write a function to find all words in a grid of letters, given a list of valid words
  3. Write a function that uses the previous functions to generate a 10 by 10 grid containing at least 10 words
  4. Update the previous function to print the grid and 10 random words from the grid

Éliminer l’ambiguïté

Évitez les références vagues et les termes ambigus qui pourraient être interprétés de plusieurs façons. Soyez explicite sur ce que vous faites référence et ce que vous voulez que Copilot fasse.

Exemples médiocres :

  • « Que fait-il ? » (la référence liée à « cela » n’est pas claire).
  • « Corriger le bogue » (ne spécifie pas le bogue ni la façon de le corriger).

Meilleurs exemples :

  • « Que fait la fonction createUser ? »
  • « Que fait le code dans votre dernière réponse ? »
  • « Correction de l’erreur de validation dans le champ d’entrée d’e-mail ».

Considérations relatives à la bibliothèque :

  • Si vous utilisez une bibliothèque rare, décrivez son objectif.
  • Pour des bibliothèques spécifiques, incluez des instructions d’importation ou spécifiez la bibliothèque que vous souhaitez utiliser.

Fournir un contexte pertinent

Aidez Copilot à comprendre la structure et les intentions de votre projet en gérant efficacement votre environnement de développement.

Dans votre IDE :

  • Ouvrez les fichiers pertinents et fermez les fichiers non liés.
  • Mettez en surbrillance des sections de code spécifiques que Copilot doit référencer.
  • Utilisez des participants de conversation comme @workspace dans Visual Studio Code ou @project dans JetBrains IDEs.

Dans Copilot Chat :

  • Référencez des fichiers ou des blocs de code spécifiques.
  • Joignez une documentation ou des spécifications pertinentes.
  • Utilisez des chemins d’accès de fichier clairs et des noms de fonction.

Itérer et affiner

Ne vous attendez pas à des résultats parfaits lors de la première tentative. Copilot fonctionne mieux lorsque vous participez à une conversation itérative, en affinant vos demandes en fonction des réponses que vous recevez.

Stratégies d’itération :

  • Si vous utilisez des suggestions en ligne, supprimez-les et réessayez avec une nouvelle invite modifiée.
  • Dans Copilot Chat, référencez les réponses précédentes et demandez des modifications spécifiques.
  • Reposez sur des solutions partielles en demandant des améliorations incrémentielles.

Maintenir l'historique pertinent des conversations

Copilot Chat utilise l’historique des conversations pour comprendre le contexte, afin de gérer cet historique stratégiquement.

Bonnes pratiques :

  • Démarrez de nouveaux threads pour différentes tâches ou projets.
  • Supprimez les demandes non pertinentes ou infructueuses susceptibles de confondre les réponses futures.
  • Gardez les conversations axées sur les fonctionnalités associées.

Suivre les bonnes pratiques de codage

La qualité de votre base de code existante affecte la capacité de Copilot à générer des suggestions appropriées. Maintenez des normes élevées dans votre code pour obtenir une meilleure assistance de l'Intelligence Artificielle.

Facteurs de qualité du code :

  • Utilisez un style et des modèles de code cohérents.
  • Choisissez des noms descriptifs pour les variables et les fonctions.
  • Ajoutez des commentaires explicites pour expliquer la logique complexe.
  • Structurez le code en composants modulaires et bien délimités.
  • Incluez des tests unitaires complets.

Note

Vous pouvez demander à Copilot d’améliorer votre qualité de code en demandant des commentaires, des suggestions de refactorisation ou en cassant des fonctions volumineuses en éléments plus petits et plus gérables.

Voici de bons exemples d'invites :

  • Clair : Décrivez exactement ce que vous voulez.
  • Spécifique : incluez les détails de disposition, de comportement ou de style.
  • Contextuel : référencer le code ou la structure existant.

Itération sur les requêtes

Si la réponse initiale de GitHub Copilot ne correspond pas à vos attentes, vous devrez peut-être ajuster votre invite. Prenez en compte ces stratégies :

  • Modifiez l’invite pour qu’elle soit plus spécifique.
  • Ajoutez un contexte à la conversation qui clarifie vos objectifs ou exigences.
  • Utilisez Copilot Chat pour poser des questions de suivi qui s’appuient sur les réponses précédentes.

Évaluation et réponse aux suggestions de Copilot

Comprendre comment évaluer les suggestions de Copilot est cruciale pour le codage d’ambiance efficace. Toutes les suggestions ne seront pas parfaites et le fait de savoir quand accepter, rejeter ou modifier les réponses améliore considérablement votre expérience de développement.

Quand accepter des suggestions

Acceptez les suggestions de Copilot quand ils :

  • Répondez à vos besoins : le code fait exactement ce que vous avez demandé.
  • Suivez les bonnes pratiques : utilisez les modèles appropriés, respectez les conventions d'affectation de noms et structurez correctement.
  • Sont bien structurés : le code est lisible, gérable et correctement mis en forme.
  • Incluez une gestion appropriée des erreurs : les cas limites et les défaillances potentielles sont pris en compte.
  • Mettre en correspondance le style de votre projet : cohérent avec les modèles et conventions de base de code existants.

Exemple de bonne suggestion à accepter :

Prompt: « Créer une fonction pour valider les adresses e-mail »

Copilot suggère :

function validateEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (typeof email !== 'string') {
        throw new Error('Email must be a string');
    }
    return emailRegex.test(email.toLowerCase());
}

Cette suggestion doit être acceptée, car elle inclut la validation d’entrée, la gestion des erreurs et utilise un modèle d’expression régulière raisonnable.

Quand rejeter des suggestions

Rejeter les suggestions de Copilot lorsqu’elles :

  • Ne répondez pas à votre invite : le code résout un problème différent de celui demandé.
  • Contiennent des vulnérabilités de sécurité : utilisez des pratiques dangereuses ou exposez des données sensibles.
  • Sont trop complexes : les tâches simples implémentées avec une complexité inutile.
  • Utilisez des méthodes désapprouvées : reposez-vous sur des API dépréciées ou obsolètes.
  • Manque de gestion des erreurs : ne comptez pas pour les scénarios d’échec potentiels.
  • Violation des normes de codage : ne suivez pas les pratiques établies de votre équipe.

Exemple de suggestion de rejet :

Prompt: « Créer une fonction de validation de mot de passe sécurisée »

Mauvaise suggestion :

function validatePassword(password) {
    return password.length > 6;
}

Cela doit être rejeté, car il est trop simpliste pour les exigences de sécurité et ne valide pas correctement la force du mot de passe.

Quand modifier des suggestions

Modifiez les suggestions de Copilot lorsqu’elles :

  • Sont principalement corrects mais nécessitent des ajustements : la logique de base est solide, mais les détails nécessitent des ajustements.
  • Besoin de fonctionnalités supplémentaires : la fonctionnalité de base est bonne, mais nécessite des améliorations.
  • Rencontrez des problèmes de style mineurs : le code fonctionne, mais ne correspond pas à vos préférences de mise en forme.
  • Exiger différents noms de variables : la logique est correcte, mais le nommage peut être amélioré.
  • Besoin d’optimisations des performances : fonctionnelles, mais peuvent être plus efficaces.

Exemple de suggestion de modification :

Copilot suggère :

function calculateTotal(items) {
    let total = 0;
    for (let i = 0; i < items.length; i++) {
        total += items[i].price;
    }
    return total;
}

Votre modification pour améliorer la lisibilité et le JavaScript moderne :

function calculateTotal(items) {
    return items.reduce((total, item) => total + item.price, 0);
}

Stratégies d’amélioration des suggestions

Quand une suggestion n’est pas tout à fait appropriée, essayez ces approches :

Affinez votre invite :

  • Ajoutez des exigences plus spécifiques.
  • Incluez des exemples d’entrée/sortie attendues.
  • Spécifiez le style de programmation ou l’infrastructure que vous utilisez.

Modifications de la demande :

  • « Rendre la fonction précédente plus robuste avec la gestion des erreurs. »
  • « Simplifiez le code que vous venez d’écrire. »
  • « Ajouter des types TypeScript à la fonction précédente ».

Générez de manière incrémentielle :

  • Commencez par une version de base et demandez des améliorations.
  • Ajoutez des fonctionnalités un par un au lieu de demander tout en même temps.
  • Testez chaque itération avant de passer à l’amélioration suivante.

Tip

Lors de la modification des suggestions, conservez les parties qui fonctionnent correctement et sont spécifiques sur ce qui doit changer. Cela permet à Copilot de comprendre vos préférences et de fournir de meilleures suggestions futures.

Summary

La création de requêtes efficaces pour GitHub Copilot est essentielle pour maximiser leur potentiel dans vibe coding. En commençant par des descriptions générales, en fournissant des exemples concrets, en décomposant des tâches complexes et en conservant une communication claire, vous pouvez guider Copilot pour générer du code de haute qualité qui répond à vos besoins. L’itération des requêtes et la capacité à évaluer les suggestions renforcera votre expérience de développement, vous permettant de profiter efficacement de l’aide de l’IA tout en gardant le contrôle sur le processus de codage.