Activité pratique

Consignes globales

Le fil conducteur de cette activité est un petit projet uv, comme ceux des séances 2 et 3. Vous n’allez pas y écrire un gros programme : le but n’est pas le programme, c’est ce que vous observez en le faisant écrire par des IA.

À partir de cette séance, vous serez autorisé(e)s à utiliser des agents IA pour vous aider à coder au semestre 5 (hors exceptions mentionnées explicitement). Cependant, il est nécessaire de bien comprendre comment ils fonctionnent avant de les utiliser, c’est pourquoi nous allons passer cette séance à observer leurs comportements. N’oubliez pas de consulter les fiches de la séance, notamment celle sur la responsabilité.

Contenu de l’activité

Repérer l’IA dans votre éditeur

Avant de se servir d’une IA, il faut savoir où elle est. Cette partie est un inventaire : vous allez déclencher les quatre formes d’assistance une par une et relever ce qu’elles coûtent.

Préparer le projet

cd IMT\S5\info\env\session4
uv init --no-package

cd IMT/S5/info/env/session4
uv init --no-package

cd IMT/S5/info/env/session4
uv init --no-package

cd IMT/S5/info/env/session4
uv init --no-package

Vérifier son compte

Si votre demande GitHub Education n’est pas encore validée, installez l’extension Continue depuis la marketplace : son offre gratuite suffit pour toute l’activité. La partie sur le choix du modèle sera simplement moins démonstrative, faute de pouvoir changer de modèle.

Les quatre intégrations IA

1. La complétion : tapez def moyenne(valeurs): puis passez à la ligne et attendez. Regardez le texte grisé sans l’accepter.
2. La discussion : ouvrez la fenêtre de chat et demandez à quoi sert uv.lock.
3. L’édition en place : sélectionnez votre fonction, appelez Ctrl+I (Cmd+I sur macOS), et demandez d’ajouter des annotations de type.
4. Le mode agent : basculez la fenêtre de discussion en mode agent et demandez de créer un fichier bonjour.py qui affiche l’heure.

Le compteur

Le choix du modèle

On va ici chercher à comparer le code produit par deux modèles, afin d’évaluer leurs différences.

L’énoncé

On veut ranger des notes d’étudiant(e)s dans des tranches via la fonction suivante :

def repartition (notes: list[float], bornes: list[float]) -> dict[str, list[float]]

• bornes est une liste de nombres, fournie dans un ordre quelconque.
• Chaque tranche va d’une borne à la suivante, fermée à gauche, ouverte à droite : $[b0, b1[$, $[b1, b2[$, …
• La dernière tranche est fermée des deux côtés : $[b(n-1), b(n)]$.
• Les notes hors de l’intervalle total sont rangées à part, sous la clé “hors bornes”.
• Le dictionnaire associe à chaque clé la liste des notes correspondantes. Toutes les tranches y figurent, même vides, ainsi que la clé “hors bornes”.
• Le dictionnaire est ordonné par borne croissante, et ses clés sont des chaînes décrivant les tranches, du type "[0, 10[", "[10, 20]" et "hors bornes".

Le juge

import unittest
from repartition import repartition # Adapter ici


class RepartitionTests (unittest.TestCase):

    def test_ordre_des_bornes (self) -> None:
        # Les bornes arrivent en désordre : le résultat doit être trié.
        resultat = repartition([5], [20, 0, 10])
        self.assertEqual(list(resultat), ["[0, 10[", "[10, 20]", "hors bornes"])

    def test_tranche_ouverte_a_droite (self) -> None:
        # 10 appartient à la tranche du haut, pas à celle du bas.
        resultat = repartition([9.99, 10], [0, 10, 20])
        self.assertEqual(resultat["[0, 10["], [9.99])
        self.assertEqual(resultat["[10, 20]"], [10])

    def test_derniere_tranche_fermee (self) -> None:
        # 20 est dans la dernière tranche, pas hors bornes.
        resultat = repartition([20], [0, 10, 20])
        self.assertEqual(resultat["[10, 20]"], [20])

    def test_hors_bornes (self) -> None:
        resultat = repartition([-1, 21], [0, 10, 20])
        self.assertEqual(resultat["hors bornes"], [-1, 21])


if __name__ == "__main__":
    unittest.main()

Si l’assistant lit les tests, il écrit du code pour les faire passer, et la comparaison ne mesure plus sa capacité à suivre l’énoncé. Or, comme expliqué dans la fiche Le contexte, plusieurs mécanismes peuvent y faire entrer le juge sans que vous le demandiez :

• Le fichier actif dans l’éditeur est joint automatiquement à vos demandes, et les autres onglets ouverts peuvent l’être aussi.
• Les recherches dans le projet (#codebase, @workspace, et celles que le mode agent lance de lui-même) peuvent tomber dessus.

{
    "files.exclude": {
        "**/test_repartition.py": true
    }
}

Plus simplement, vous pouvez également déplacer le fichier dans un dossier hors du projet le temps d’utiliser vos agents, par exemple sur votre bureau. Pensez également à fermer l’onglet.

Générer la fonction avec deux modèles différents

Vous pouvez maintenant rouvrir le juge : retirez l’exclusion de .vscode/settings.json, ou remettez le fichier dans votre projet si vous l’aviez déplacé.

uv run python -m unittest test_repartition.py

uv run python -m unittest test_repartition.py

uv run python -m unittest test_repartition.py

uv run python -m unittest test_repartition.py

Regardez de nouveau le compteur de requêtes. Combien cette partie a-t-elle consommé ?

Le contexte

La complétion imite votre style

Vous allez maintenant vérifier, en le provoquant, que la complétion reproduit ce qu’elle lit juste au-dessus du curseur.

Poser un style

def moyenne (valeurs : list[float]) -> float :
    """
    Calcule la moyenne arithmétique d'une série de valeurs.

    Parameters
    ----------
    valeurs : list[float]
        La série à résumer. Ne doit pas être vide.

    Returns
    -------
    float
        La moyenne des valeurs.
    """
    if len(valeurs) == 0 :
        raise ValueError("La série est vide.")
    resultat = sum(valeurs) / len(valeurs)
    return resultat


def etendue (valeurs : list[float]) -> float :
    """
    Calcule l'étendue d'une série de valeurs, c'est-à-dire l'écart entre
    la plus grande et la plus petite.

    Parameters
    ----------
    valeurs : list[float]
        La série à résumer. Ne doit pas être vide.

    Returns
    -------
    float
        L'étendue des valeurs.
    """
    if len(valeurs) == 0 :
        raise ValueError("La série est vide.")
    resultat = max(valeurs) - min(valeurs)
    return resultat

Observer la contagion

def variance (valeurs : list[float]) -> float :

Réutiliser ou réécrire

C’est l’expérience la plus importante de la séance. Vous allez poser la même demande à deux endroits : dans l’éditeur, et dans un onglet de navigateur. Puis vous comparerez le code obtenu.

La demande

On veut ajouter à stats.py une fonction resume(valeurs) qui renvoie un dictionnaire contenant la moyenne, l’étendue et le nombre de valeurs.

Cette fonction n’a aucune raison de recalculer quoi que ce soit : moyenne et etendue existent déjà, juste au-dessus.

Chat externe Vs. Assistant intégré

À présent, comparons avec le chat intégré à VS Code pour voir l’importance du contexte.

Rendre le contexte durable

Répéter « réutilise les fonctions existantes » à chaque demande est fastidieux. On peut l’écrire une fois pour toutes.

Découvrir le mode agent

Dans la première partie, vous avez déclenché le mode agent sur une tâche triviale. Vous allez maintenant lui confier une vraie tâche sur votre projet, qui demande de lire du code existant, de créer plusieurs fichiers et d’exécuter une commande. Le but n’est pas tant le résultat que ce que l’agent fait pour y arriver, à comparer avec la boucle décrite dans la fiche L’IA dans l’IDE.

Confier une tâche à l’agent

Crée un script main.py qui lit des notes dans un fichier notes.txt (une note par ligne), puis affiche leur moyenne et leur étendue en réutilisant les fonctions de stats.py. Crée aussi un fichier notes.txt d’exemple, puis exécute main.py pour vérifier que tout fonctionne.

Observer ce qu’il fait

1. Les fichiers qu’il lit, et comment il les trouve : les avez-vous désignés, ou les a-t-il cherchés lui-même ?
2. Les fichiers qu’il crée ou modifie. En a-t-il touché un que vous n’aviez pas mentionné ?
3. Les commandes qu’il veut exécuter, et le moment où il vous demande votre accord. Lisez chaque commande avant d’accepter. Utilise-t-elle uv run, ou appelle-t-elle python directement ?
4. Le nombre de tours : combien de fois a-t-il agi, lu un résultat, puis agi de nouveau ?

Relire avant de conserver

À la fin, VS Code liste les fichiers modifiés par l’agent, et propose de conserver ou d’annuler les modifications de chacun. Tant que vous n’avez pas tranché, rien n’est définitivement validé.

1. main.py appelle-t-il moyenne et etendue, ou recalcule-t-il de son côté ?
2. Le style de stats.py et les consignes de .github/copilot-instructions.md sont-ils respectés ?
3. Que se passe-t-il si notes.txt contient une ligne vide, ou une ligne abc ? Ajoutez-en une, et lancez vous-même le script avec uv run python main.py.

Demander une correction

Regardez enfin le compteur de requêtes. Combien cette partie a-t-elle consommé, comparée à une simple question dans la fenêtre de discussion ?

Pour aller plus loin

Le harnais : ce que l’agent peut vérifier lui-même

Un agent seul ne peut que produire du texte plausible. Ce qui le rend réellement utile, c’est le harnais : l’ensemble des outils qu’on lui donne pour vérifier son propre travail : exécuter les tests, lire une erreur, relancer. Sans harnais, il devine. Avec, il itère.

Vous allez mesurer la différence sur le même énoncé.

Sans harnais

cd sans_harnais
uv run python -m unittest test_duree.py

cd sans_harnais
uv run python -m unittest test_duree.py

cd sans_harnais
uv run python -m unittest test_duree.py

cd sans_harnais
uv run python -m unittest test_duree.py

Combien passent du premier coup ?

Avec harnais

Laissez l’agent travailler, et regardez ce qu’il fait : les commandes qu’il lance, les sorties qu’il lit, les corrections qu’il enchaîne. Combien de tours lui a-t-il fallu ? Sur quoi s’est-il repris ?

Regardez une dernière fois le compteur de requêtes. Quelle partie de l’activité a le plus consommé ? Est-ce celle qui vous a le plus servi ?

Pour aller encore plus loin

• How AI assistance impacts the formation of coding skills

  Une étude d’Anthropic sur l’effet de l’assistance sur l’apprentissage de la programmation, et sur les usages qui consolident ou érodent les compétences (en anglais). À lire avant de prendre vos habitudes pour le projet.
• OWASP Top 10 for Large Language Model Applications

  La liste de référence des failles propres aux applications construites autour d’un modèle : injection de prompt, fuite de données, chaîne d’approvisionnement (en anglais).
• Building effective agents

  Ce qui distingue un enchaînement d’appels bien conçu d’un agent autonome, et pourquoi la solution la plus simple qui marche est presque toujours la bonne (en anglais). Le prolongement direct de la partie sur le harnais.
• Prompt injection

  Une série d’articles de Simon Willison sur une vulnérabilité structurelle des agents : un agent qui lit un fichier, une page web ou un ticket peut y trouver des instructions et les suivre (en anglais).