Écrivez et comprenez du code grâce à Copilot Chat

Copilot Chat, c’est un peu comme avoir un mentor de développement directement dans votre navigateur. Vous lui posez une question, il vous répond avec des explications, du code, ou même une approche alternative.
Et le plus fort, c’est qu’il s’adapte à votre niveau : il peut simplifier ou détailler plus amplement selon la façon dont vous lui parlez.

Accédez à Copilot gratuitement

Avant de lui demander d’écrire du code, il faut déjà savoir comment accéder à Copilot Web.

Oui, il vous faudra un compte Microsoft (Si vous avez déjà un compte Outlook, Xbox, Teams, Skype, etc. ; alors vous avez déjà un compte Microsoft).

Si vous n’en avez pas encore, ça se fait en quelques clics, gratuitement. 

Une fois connecté, vous arrivez sur une interface très épurée :

• Au centre, un message d’accueil chaleureux vous invite à démarrer la conversation : 

“Bonjour, c’est agréable de vous voir. Quoi de neuf ?”

• Juste en dessous, la zone de saisie vous permet d’écrire vos messages à Copilot ou d’utiliser le micro si vous préférez parler.

• Des suggestions rapides sont également proposées pour vous inspirer ou gagner du temps : 

  • Créer une image

  • Répondre à un questionnaire

  • Rédiger un texte

• Sur la barre latérale gauche, vous retrouvez les icônes principales : 

  • vos conversations,

  • vos fichiers,

  • vos plugins,

  • et les paramètres.

Générez du code 

Bon, maintenant que vous êtes connecté à Copilot, on va passer à la partie la plus amusante : lui faire écrire du code.

Presque, mais pour qu’il réponde précisément, il faut lui donner le bon contexte.

Imaginons que vous soyez en train de développer une petite application web. Vous voulez créer une fonction en JavaScript qui calcule le montant total d’un panier avec une remise appliquée.
Plutôt que de chercher des bouts de code sur Internet, vous allez simplement demander à Copilot : 

“Écris une fonction en JavaScript qui prend un prix total et un taux de remise et retourne le montant final. Retourne uniquement le code.”

Quelques secondes plus tard, il vous propose un code clair :

function calculerMontantFinal(prixTotal, tauxRemise) {
  const remise = prixTotal * (tauxRemise / 100);
  return prixTotal - remise;
}

Tout à fait mais on ne va pas s'arrêter là, on va affiner la demande en ajoutant :

“Assure-toi que le code soit compatible avec ES6 et inclut un exemple d’utilisation.”

Copilot renvoie maintenant la même fonction, cette fois avec une version plus moderne du code (  const  ,  arrow function  , etc.) et un petit exemple de test à la fin :

// Fonction compatible ES6 pour calculer le montant final après remise
const calculerMontantFinal = (prixTotal, tauxRemise) => {
  const remise = prixTotal * (tauxRemise / 100);
  return prixTotal - remise;
};

// Exemple d'utilisation
const prixInitial = 200;
const remisePourcentage = 15;
const montantFinal = calculerMontantFinal(prixInitial, remisePourcentage);

console.log(`Montant final après remise : €${montantFinal.toFixed(2)}`);

Pas de problème, vous pouvez simplement lui demander : 

“Convertis ce code JavaScript en Python, avec les bonnes conventions et librairies natives.”

Et voilà ce que ça donne :

def calculer_montant_final(prix_total: float, taux_remise: float) -> float:
    """Calcule le montant final après application d'une remise."""
    remise = prix_total * (taux_remise / 100)
    return prix_total - remise

# Exemple d'utilisation
if __name__ == "__main__":
    prix_initial = 200
    remise_pourcentage = 15
    montant_final = calculer_montant_final(prix_initial, remise_pourcentage)
    print(f"Montant final après remise : €{montant_final:.2f}")

Copilot comprend la logique et génère une version identique mais en Python, avec les bons noms de variables, la syntaxe correcte et parfois même les exceptions gérées.

Très simple encore une fois, vous n’avez pas besoin de sortir de Copilot, Vous pouvez directement lui demander de faire un test : 

“Montre-moi un exemple d’entrée et de sortie pour vérifier que le résultat est le même.”

Et il proposera un petit jeu de tests, c’est très pratique pour s’assurer que le code d’origine et le code converti donnent bien les mêmes résultats :

Voici un exemple d’entrée et de sortie pour les deux versions du code (JavaScript et Python), afin de vérifier qu’elles produisent le même résultat :

Exemple d’entrée

• Prix total : 200

• Taux de remise : 15 (%)

Sortie attendue

• Montant final : 170.00

En Javascript :

const montantFinal = calculerMontantFinal(200, 15);
console.log(montantFinal); // Affiche : 170

En Python :

montant_final = calculer_montant_final(200, 15)
print(montant_final)  # Affiche : 170.0

Fabriquez un bon prompt 

Comme tout bon assistant IA, Copilot  fait de son mieux avec ce que vous lui avez dit mais si la demande est floue, il va essayer de deviner… et quand l’IA essaie de deviner, les résultats sont rarement ceux que l’’on voulait.

Les 5 étapes d’un bon prompt : 

1. Donner le contexte de départ. Expliquez rapidement dans quel cadre vous voulez utiliser le code. Est-ce pour un site web, un script d’analyse de données, une application mobile ou un automatisme Excel ? Plus le contexte est clair, plus Copilot comprendra votre objectif.

2. Préciser le langage de programmation. Indiquez explicitement le langage que vous voulez utiliser (Python, JavaScript, Java, etc.). Vous pouvez également spécifier les librairies à utiliser.

3. Avoir un objectif clair. Décrivez concrètement ce que le code doit faire.

4. Créer des contraintes à respecter. Mentionnez les critères techniques ou stylistiques importants s’il y en a.

5. Indiquer le résultat attendu. Précisez ce que vous souhaitez avoir en sortie.

Si on reprend notre prompt initial, voici la forme qu’il pourrait avoir : 

1. #Contexte. Je travaille sur un petit site e-commerce et je veux automatiser le calcul du prix après remise

2. #Langage. JavaScript

3. #Objectif. Écris une fonction en JavaScript qui prend un prix et un taux de remise, puis retourne le montant final à payer.

4. #Contraintes. Utilise la syntaxe moderne ES6 et gère les valeurs négatives

5. #Résultat. Retourne uniquement le code, avec des explications et ajoute un exemple d’utilisation à la fin.

Parce qu’un bon prompt, c’est un peu comme donner un brief clair à un collègue.
Imaginez que vous vous adressez à un développeur de votre équipe et que vous lui disiez : 

“Je travaille sur un petit site e-commerce et j’aimerais automatiser le calcul du prix après remise. Peux-tu écrire une fonction en JavaScript qui prend en entrée un prix et un taux de remise, puis retourne le montant final à payer ? Utilise la syntaxe moderne ES6, gère les valeurs négatives, et ne me donne que le code, sans explication, avec un petit exemple d’utilisation à la fin.”

Avec un brief aussi précis, votre collègue rendrait un code propre, ciblé et immédiatement exploitable.  C’est exactement le même principe avec un prompt bien formulé : plus la demande est claire et contextualisée, plus la réponse de l’IA sera utile et pertinente.

À vous de jouer !

Vous démarrez dans votre nouveau rôle de développeur junior au sein d’une entreprise.

Votre manager vous demande de commencer à automatiser certaines tâches d’analyse de données pour gagner du temps dans les reportings.

Pour cela, vous souhaitez demander à Copilot de vous aider à créer une fonction Python capable d’analyser rapidement une liste de valeurs numériques (par exemple des ventes, des notes ou des mesures).

Consigne

Rédigez un prompt complet à destination de Copilot pour lui demander de créer une fonction Python qui calcule la moyenne, la médiane, la valeur minimale et la valeur maximale des données suivantes : les données suivantes 10, 2, 8, 4.

Vous devrez également lui demander de faire un test sur ces mêmes données suivantes 10, 2, 8, 4.

Exemple de prompt

Contexte : Je veux créer une petite fonction Python pour m’entraîner à manipuler des listes de nombres.

Langage : Python 3, sans utiliser de librairies externes.

Objectif du code : Écrire une fonction  analyze_numbers(numbers)  qui prend une liste de nombres en entrée et retourne un dictionnaire contenant :

• la moyenne,

• la médiane,

• la valeur minimale,

• la valeur maximale,

Contraintes :

• Le code doit gérer les erreurs (liste vide, valeurs non numériques).

• Ajouter des commentaires pour expliquer les étapes.

Sortie attendue :

• Le dictionnaire final affiché dans la console.

Exemple de résultat

def analyze_numbers(numbers):
    """
    Analyse une liste de nombres et retourne un dictionnaire contenant :
    - la moyenne
    - la médiane
    - la valeur minimale
    - la valeur maximale
    """

    # Vérifie que la liste n'est pas vide
    if not numbers:
        raise ValueError("La liste est vide.")

    # Vérifie que tous les éléments sont des nombres (int ou float)
    for n in numbers:
        if not isinstance(n, (int, float)):
            raise TypeError(f"Valeur non numérique détectée : {n}")

    # Trie la liste pour le calcul de la médiane
    sorted_numbers = sorted(numbers)
    n = len(sorted_numbers)

    # Calcul de la moyenne
    moyenne = sum(sorted_numbers) / n

    # Calcul de la médiane
    if n % 2 == 1:
        mediane = sorted_numbers[n // 2]
    else:
        milieu1 = sorted_numbers[n // 2 - 1]
        milieu2 = sorted_numbers[n // 2]
        mediane = (milieu1 + milieu2) / 2

    # Valeur minimale et maximale
    valeur_min = sorted_numbers[0]
    valeur_max = sorted_numbers[-1]

    # Construction du dictionnaire de résultats
    resultats = {
        "moyenne": moyenne,
        "médiane": mediane,
        "minimum": valeur_min,
        "maximum": valeur_max
    }

    return resultats

# Exemple d'utilisation avec la liste [10, 2, 8, 4]
if __name__ == "__main__":
    liste = [10, 2, 8, 4]
    try:
        stats = analyze_numbers(liste)
        print("Résultats de l'analyse :", stats)
    except (ValueError, TypeError) as e:
        print("Erreur :", e)

Résultats de l'analyse dans la console : 

{'moyenne': 6.0, 'médiane': 6.0, 'minimum': 2, 'maximum': 10}

Demandez à Copilot d’expliquer le code généré

On va maintenant récupérer le code généré par Copilot mais avant de l’utiliser tel quel, on va se le faire expliquer.
Collez votre code dans Copilot Chat et demandez-lui simplement : “Explique-moi ce que fait ce code, ligne par ligne.”

Copilot va décrire chaque étape, les variables utilisées, la logique du calcul, et parfois même des points d’attention auxquels vous n'auriez pas pensé :

C’est aussi le moment idéal pour lui demander : 

“Quels sont les cas limites que ce code ne gère pas ?”

Il listera souvent les fameux “edge cases”, ces situations qu’on oublie facilement : un zéro, une valeur négative, une donnée vide ou une entrée inattendue.

Une fois que tout est clair, vous pouvez demander à Copilot d’ajouter des commentaires pour expliquer le code. vous pouvez lui dire : 

“Ajoute des documentaires utiles à cette fonction, sans modifier le comportement.”

En général, il va renvoyer un code enrichi de descriptions précises :

• les paramètres,

• le rôle de la fonction, 

• la valeur de retour, 

• les erreurs possibles.

Quand le code semble correct, il est temps de vérifier s’il fonctionne vraiment. Et là encore, Copilot peut générer des tests unitaires avec le framework de votre choix. Vous pouvez lui demander : 

“Écris des tests unitaires en Python (pytest) pour vérifier les cas normaux, les valeurs limites et les entrées invalides.”

Il proposera une série de tests couvrant tous les cas importants :

• le fonctionnement de base, 

• les extrêmes (comme un prix à zéro ou une remise à 100 %)

• les erreurs (valeurs négatives, types incorrects…), etc :

import pytest
from math import inf, nan
from your_module import analyze_numbers  # Remplace 'your_module' par le nom réel de ton fichier sans .py

def test_liste_valide_pair():
    numbers = [10, 2, 8, 4]
    result = analyze_numbers(numbers)
    assert result["moyenne"] == 6.0
    assert result["médiane"] == 6.0
    assert result["minimum"] == 2
    assert result["maximum"] == 10

def test_liste_valide_impair():
    numbers = [3, 9, 6]
    result = analyze_numbers(numbers)
    assert result["moyenne"] == 6.0
    assert result["médiane"] == 6
    assert result["minimum"] == 3
    assert result["maximum"] == 9

def test_liste_vide():
    with pytest.raises(ValueError, match="La liste est vide."):
        analyze_numbers([])

def test_valeurs_non_numeriques():
    with pytest.raises(TypeError, match="Valeur non numérique détectée"):
        analyze_numbers([1, "a", 3])

def test_valeurs_nan_inf():
    with pytest.raises(TypeError):
        analyze_numbers([1, float('nan'), 3])

def test_valeurs_booleennes():
    with pytest.raises(TypeError):
        analyze_numbers([1, True, 3])

Et si vous préférez JavaScript, demandez-lui la même chose en Jest !

Si vous avez une erreur No Module Named ‘Pytest  ; vous pouvez lancer le code suivant dans la console pour installer les librairies :

# vérifier la version de Python

python3 --version

# option A : installer pytest globalement dans le conteneur

python3 -m pip install --upgrade pip setuptools wheel

python3 -m pip install pytest

# option B (recommandé) : utiliser un virtualenv isolé

python3 -m venv .venv

source .venv/bin/activate

pip install pytest

# lancer tous les tests (mode verbeux court)

python3 -m pytest -q

# ou lancer uniquement le fichier de tests

python3 -m pytest -q tests/test_analyze_numbers.py

À vous de jouer !

Vous venez de découvrir la fonctionanalyze_numbers(numbers)et son fonctionnement détaillé. C’est le moment de vérifier que vous avez bien compris chaque étape du code.

Reprenez la fonction  analyze_numbers(numbers)  dans votre environnement de travail et demandez des explications jusqu’à comprendre l’ensemble du code.

En résumé

• Copilot Chat est un assistant de développement intégré dans le navigateur, capable de générer, expliquer et corriger du code en langage naturel. Il agit comme un mentor virtuel, adaptant son niveau de détail selon les besoins de l’utilisateur.

• Copilot permet d’écrire du code dans plusieurs langages (Python, JavaScript, Java…), de le convertir, de le tester et de le documenter. Son efficacité dépend toutefois de la qualité du prompt : un brief clair, structuré et contextualisé améliore fortement la pertinence du résultat.

• L’outil aide à comprendre le code existant, identifier les cas limites et générer des tests unitaires, facilitant ainsi l’apprentissage et la montée en compétence.

• Ses avantages sont la rapidité, la pédagogie et la polyvalence, mais il reste dépendant du contexte fourni et peut générer des erreurs si la demande est vague. L’objectif n’est pas de remplacer le développeur, mais de l’accompagner dans une approche plus efficace, où l’humain reste au centre de la compréhension et de la validation du code.