Activer Copilot et les suggestions inline

3.1 Installation et activation de Copilot dans l’IDE

Définition simple

Installer GitHub Copilot dans l’IDE signifie ajouter l’extension ou le plugin Copilot dans ton environnement de développement, puis te connecter avec ton compte GitHub.

Copilot peut ensuite t’aider à :

• générer du code ;
• compléter du code existant ;
• expliquer du code ;
• générer des tests ;
• proposer des corrections ;
• aider à refactorer ;
• répondre à des questions dans le contexte de ton projet.

GitHub documente l’usage de Copilot dans plusieurs IDE, notamment Visual Studio Code, JetBrains IDEs, Visual Studio, Eclipse et Xcode.

Installation dans VS Code

Dans VS Code, le flux classique est :

1. Installer l’extension GitHub Copilot.
2. Installer aussi GitHub Copilot Chat si nécessaire.
3. Se connecter avec son compte GitHub.
4. Vérifier que l’abonnement ou l’accès Copilot est actif.
5. Ouvrir un projet.
6. Commencer à coder ou ouvrir le panneau Copilot Chat.

Exemple d’usage immédiat :

def calculate_discount(price, percentage):

Copilot peut proposer automatiquement :

def calculate_discount(price, percentage):
    return price - (price * percentage / 100)

Installation dans JetBrains

Dans IntelliJ, PyCharm, WebStorm ou les autres IDE JetBrains :

1. Aller dans les plugins.
2. Chercher GitHub Copilot.
3. Installer le plugin.
4. Redémarrer l’IDE si nécessaire.
5. Se connecter à GitHub.
6. Activer Copilot dans les paramètres.

GitHub précise que dans les IDE JetBrains, Copilot peut générer des suggestions de code, expliquer le code dans l’éditeur et suggérer des corrections.

Installation dans Visual Studio

Dans Visual Studio :

1. Vérifier que la version supporte Copilot.
2. Installer ou activer l’extension GitHub Copilot.
3. Se connecter à GitHub.
4. Ouvrir le menu ou la fenêtre Copilot Chat.
5. Utiliser les suggestions dans l’éditeur.

Quel bouton exact cliquer dans VS Code ?

Un développeur veut utiliser Copilot directement dans son environnement de développement.
Quelle première étape doit-il effectuer ?

Installer/activer GitHub Copilot dans l’IDE et s’authentifier avec un compte GitHub disposant d’un accès Copilot.

3.2 Inline suggestions

Définition

Les inline suggestions sont les suggestions de code qui apparaissent directement pendant que tu écris dans ton éditeur.

C’est l’usage le plus connu de GitHub Copilot : tu commences à écrire du code, et Copilot propose une continuation.

GitHub décrit les suggestions de code dans l’IDE comme une fonctionnalité centrale de Copilot, disponible dans différents environnements de développement.

Vocabulaire de reconnaissance : ghost text

La suggestion inline apparaît souvent sous forme de ghost text : un texte grisé ou atténué affiché directement après le curseur. Le développeur peut l’accepter, par exemple avec Tab dans VS Code lorsque cette action est proposée par la surface, ou la rejeter et continuer à écrire. Ghost text désigne la présentation visuelle de la suggestion, pas un nouvel objectif.

Pour une même entrée, Copilot peut proposer plusieurs suggestions : on parcourt les alternatives, on en ouvre plusieurs à la fois dans un nouvel onglet, ou on rejette tout. La façon d’y accéder dépend de l’IDE.

Exemple simple

Tu écris :

function isValidEmail(email) {

Copilot peut proposer :

function isValidEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

C’est rapide et utile, mais ce n’est pas magique.

Tu dois vérifier :

• la regex est-elle suffisante ?
• le cas métier est-il bien couvert ?
• faut-il gérer null ou undefined ?
• faut-il normaliser l’email ?
• faut-il ajouter des tests ?

Exemple plus réaliste

Tu écris :

def get_active_users(users):

Copilot peut proposer :

def get_active_users(users):
    return [user for user in users if user.get("active")]

C’est propre si tes users sont des dictionnaires.

Mais si ton modèle est une classe ?

class User:
    def __init__(self, name, active):
        self.name = name
        self.active = active

Alors le code attendu serait plutôt :

def get_active_users(users):
    return [user for user in users if user.active]

Donc Copilot dépend énormément du contexte.

Comment améliorer les inline suggestions ?

Copilot se base sur le contexte disponible :

• le fichier courant ;
• les noms de fonctions ;
• les commentaires ;
• les types ;
• les imports ;
• les fichiers ouverts ;
• parfois le contexte du projet selon l’environnement et les permissions.

Plus ton intention est claire, meilleure est la suggestion.

Mauvais exemple

def process(data):

Copilot ne sait pas vraiment ce que tu veux.

Meilleur exemple

def process_order_events(events: list[dict]) -> list[dict]:
    """
    Filter invalid order events, normalize the timestamp field,
    and return only events with status 'confirmed'.
    """

Là, Copilot a beaucoup plus de contexte.

Il peut proposer quelque chose comme :

from datetime import datetime

def process_order_events(events: list[dict]) -> list[dict]:
    """
    Filter invalid order events, normalize the timestamp field,
    and return only events with status 'confirmed'.
    """
    processed = []

    for event in events:
        if not event.get("order_id") or event.get("status") != "confirmed":
            continue

        timestamp = event.get("timestamp")
        if isinstance(timestamp, str):
            timestamp = datetime.fromisoformat(timestamp)

        processed.append({
            **event,
            "timestamp": timestamp,
        })

    return processed

Bonnes pratiques avec inline suggestions

Utilise les inline suggestions pour :

• écrire du boilerplate ;
• compléter des fonctions simples ;
• générer des mappings ;
• créer des DTO ;
• écrire des helpers ;
• produire des exemples ;
• accélérer des patterns connus.

Évite de les accepter aveuglément pour :

• sécurité ;
• authentification ;
• IAM ;
• chiffrement ;
• données sensibles ;
• logique métier critique ;
• transactions financières ;
• scripts destructifs.

A developer receives an inline suggestion from Copilot that compiles successfully.
What should the developer do before merging it?

Review, test, and validate the suggestion before merging.

Accept it because Copilot generated it.