Le code généré par une IA est une proposition, jamais une preuve. Entre la proposition et l'intégration, il y a une échelle de vérification — et elle se construit.
⏱️ Durée : environ 115 minutes · 🎓 Niveau : avancé · 🏅 Badge : Vérificateur impitoyable
🎬 L'histoire
Un développeur de HashBox demande à un assistant une fonction qui fusionne des intervalles de dates (réservations de salles). Le code arrive, élégant, commenté, avec trois exemples qui passent. Il est fusionné. Deux semaines plus tard, une salle est réservée deux fois : la fonction ne fusionne pas les intervalles qui se touchent exactement, modifie la liste d'entrée, et plante sur une liste vide. Personne n'avait lu le code ligne à ligne : « il passait ses tests ». Ses propres tests, écrits par la même IA.
« Un test écrit par l'auteur d'une solution partage ses angles morts, dit Sam. Quand l'auteur est une IA, c'est pareil. La vérification doit être indépendante de la génération : une spécification écrite par toi, des tests de propriétés, une comparaison avec une implémentation de référence lente mais évidente, une analyse statique, des dépendances qui existent vraiment. Et c'est ton nom qui est sur le commit. »
Tu apprends l'échelle de vérification d'un code généré : spécification, relecture, analyse statique (imports inventés, appels dangereux), tests d'exemples, tests de propriétés, tests différentiels, mutation, exécution isolée — et tu construis un vérificateur automatique qui trie des candidats « produits par une IA ».
🎯 Ta mission
À la fin, je serai capable de :
- énoncer l'échelle de vérification d'une sortie générée (spécification, lecture, analyse statique, tests, propriétés, différentiel, mutation)
- détecter dépendances et API inventées, appels dangereux et effets de bord
- écrire des tests de propriétés et un test différentiel contre une implémentation de référence
- exécuter du code non fiable dans un processus isolé avec délai
- vérifier des citations et références produites par un modèle
🧩 Défi d'échauffement (5 XP)
Un entrepreneur vous apporte un plan que son assistant a rédigé : tableaux, chiffres, références à des études. Vous devez le valider avant qu'il parte à la banque. Que vérifies-tu en premier ? Les chiffres cités ? L'existence des études ? La cohérence des totaux ? Comment t'y prends-tu si le plan fait 80 pages ? Quelle partie peux-tu vérifier mécaniquement ?
💡 Le concept
Le principe : indépendance
Ce qui a été produit par une source ne peut pas être validé par la même source avec les mêmes angles morts.
Un modèle qui écrit le code et ses tests peut reproduire la même fausse hypothèse dans les deux. La vérification repose sur des éléments que tu contrôles : une spécification écrite par un humain, un oracle (référence, propriété, règle métier), des outils déterministes.
Le principe de coût : vérifier doit coûter moins que produire
Si vérifier une sortie prend plus de temps que l'écrire soi-même, l'IA n'apporte rien. Les bons cas d'usage : production coûteuse, vérification bon marché (un test qui passe, une compilation, une requête qu'on relance, un calcul refaisable). Les mauvais : sorties difficiles à valider sans expertise.
L'échelle de vérification
| Niveau | Vérification | Détecte |
|---|---|---|
| 0 | Spécification écrite avant de demander | ambiguïtés, oublis |
| 1 | Lecture (comprendre chaque ligne, pouvoir l'expliquer) | logique fausse, code inutile |
| 2 | Analyse statique : syntaxe, imports qui existent, appels dangereux, types, lint | API inventées, eval, secrets |
| 3 | Tests d'exemples (cas nominaux, limites, erreurs) | bugs évidents |
| 4 | Tests de propriétés (aléatoires, invariants) | cas imprévus, effets de bord |
| 5 | Test différentiel contre une référence simple et lente | divergences de comportement |
| 6 |
On monte l'échelle selon l'enjeu.
Les défauts typiques du code généré
| Défaut | Exemple | Détecteur |
|---|---|---|
| Dépendance ou fonction inventée | import intervaltools (inexistant) | vérifier que les modules/attributs existent |
| Cas limites oubliés | liste vide, bornes qui se touchent | tests de limites, propriétés |
| Effet de bord | modifie l'argument | propriété « l'entrée n'est pas modifiée » |
| Version de l'API périmée | fonction supprimée | exécution réelle |
| Appel dangereux | eval, os.system, pickle.loads | analyse statique (HEF-100) |
| Sécurité subtile | injection SQL par concaténation |
Les tests de propriétés
Au lieu de choisir des exemples, énoncer des propriétés vraies pour toute entrée et les vérifier sur des milliers d'entrées aléatoires (graine fixée). Pour une fusion d'intervalles : (1) le résultat est trié et sans chevauchement ; (2) il couvre exactement les mêmes points que l'entrée ; (3) l'entrée n'est pas modifiée ; (4) fusionner deux fois = fusionner une fois (idempotence).
Le test différentiel
Écrire (ou obtenir d'une source fiable) une implémentation trop simple pour être fausse (par exemple, lister tous les points entiers couverts), puis comparer sur beaucoup d'entrées aléatoires. Les divergences désignent des bugs.
Exécuter du code non fiable
Code généré = code non fiable tant qu'il n'est pas vérifié. L'exécuter : dans un processus séparé, avec délai maximal, sans accès réseau/fichiers sensibles (conteneur, utilisateur sans droits), mémoire limitée (HEF-100, HEF-120).
Citations et références
Les modèles produisent des références plausibles mais inexistantes. Vérifier : l'existence (URL, identifiant, DOI), que la source contient bien l'affirmation, que les chiffres correspondent. Un vérificateur automatique peut contrôler l'existence ; la concordance relève d'une lecture humaine.
La responsabilité
Celui qui fusionne répond du code. « C'est l'IA qui l'a écrit » n'est pas un argument de revue. La traçabilité (quelle IA, quel prompt, quelle vérification) aide à comprendre, pas à se décharger.
Éviter l'atrophie des compétences
Si tu ne fais plus que valider sans comprendre, tu perds la capacité de repérer les erreurs. Parades : expliquer le code à voix haute (« explain-back »), écrire d'abord ta propre approche pour les tâches importantes, relire sans l'IA de temps en temps, pratiquer le débogage.
🧠 Astuce : avant de lire le code généré, écris tes trois cas de test les plus vicieux. Si tu ne sais pas lesquels, tu ne sais pas encore ce que la fonction doit faire.
🔍 Exemple pas à pas
Problème : construire un vérificateur automatique qui trie cinq candidats « produits par une IA » pour une fonction fusionner(intervalles). Les contrôles : analyse statique (imports inexistants, appels dangereux), exécution isolée avec délai dans un sous-processus, tests d'exemples, tests de propriétés et test différentiel contre une référence évidente.
import ast, importlib.util, json, subprocess, sys, textwrap
# ---------------- les candidats « générés par une IA » ----------------
CANDIDATS = {
"A_correct": '''
def fusionner(intervalles):
resultat = []
for debut, fin in sorted(intervalles):
if resultat and debut <= resultat[-1][1]:
resultat[-1] = (resultat[-1][0], max(resultat[-1][1], fin))
else:
resultat.append((debut, fin))
return resultat
''',
"B_bornes_qui_se_touchent": '''
def fusionner(intervalles):
resultat = []
for debut, fin in sorted(intervalles):
if resultat and debut < resultat[-1][1]:
resultat[-1] = (resultat[-1][0], max(resultat[-1][1], fin))
else:
resultat.append((debut, fin))
return resultat
''',
"C_dependance_inventee": '''
from intervaltools import merge_intervals
def fusionner(intervalles):
return merge_intervals(intervalles)
''',
"D_modifie_l_entree": '''
def fusionner(intervalles):
intervalles.sort()
resultat = [intervalles[0]]
for debut, fin in intervalles[1:]:
if debut <= resultat[-1][1]:
resultat[-1] = (resultat[-1][0], max(resultat[-1][1], fin))
else:
resultat.append((debut, fin))
return resultat
''',
"E_appel_dangereux": '''
import os
def fusionner(intervalles):
os.system("echo exfiltration")
return sorted(set(intervalles))
''',
}
# ---------------- niveau 2 : analyse statique ----------------
INTERDITS = {"eval", "exec", "compile", "__import__"}
MODULES_INTERDITS = {"os", "subprocess", "socket", "shutil", "pickle", "ctypes"}
def analyse_statique(code):
problemes = []
try: arbre = ast.parse(code)
except SyntaxError e: []
n ast.walk(arbre):
modules = []
(n, ast.Import): modules = [a.name a n.names]
(n, ast.ImportFrom) n.module: modules = [n.module]
m modules:
racine = m.split()[]
racine MODULES_INTERDITS: problemes.append()
importlib.util.find_spec(racine) : problemes.append()
(n, ast.Call) (n.func, ast.Name) n.func. INTERDITS: problemes.append()
problemes
HARNAIS = textwrap.dedent()
():
verdict = {: nom, : analyse_statique(code)}
verdict[]:
verdict[] = ; verdict
tempfile, os
tempfile.TemporaryDirectory() d:
(os.path.join(d, ), ).write(code); (os.path.join(d, ), ).write(HARNAIS)
:
r = subprocess.run([sys.executable, , os.path.join(d, ), os.path.join(d, )], capture_output=, text=, timeout=delai, cwd=d)
subprocess.TimeoutExpired:
verdict[] = ; verdict
r.returncode != :
verdict[] = ; verdict[] = r.stderr.strip().splitlines()[-] r.stderr.strip() ; verdict
rapport = json.loads(r.stdout.strip().splitlines()[-]); verdict.update(rapport)
bons = rapport[] rapport[] rapport[] == rapport[]
verdict[] = bons
verdict
()
decisions = {}
nom, code CANDIDATS.items():
v = verifier(nom, code); decisions[nom] = v[]
details = v[] [k k (, , , ) v.get(k) (, [], , )]
()
decisions[].startswith() decisions[] == decisions[].startswith()
decisions[].startswith() decisions[].startswith()
(, [n n, c CANDIDATS.items() analyse_statique(c)])
Lecture :
- A est accepté pour revue humaine — jamais directement intégré : le vérificateur élimine le mauvais, il ne démontre pas le bon.
- B passe l'analyse statique et la plupart des exemples, mais échoue aux propriétés et au test différentiel : il ne fusionne pas les intervalles qui se touchent à la borne (l'erreur de HashBox).
- C importe une bibliothèque qui n'existe pas : l'analyse statique détecte la hallucination avant toute exécution.
- D passe sur certaines entrées mais modifie la liste d'entrée et plante sur la liste vide : détecté par les propriétés et l'exécution.
- E contient un appel système : refusé avant exécution (jamais lancé).
Chaque contrôle est indépendant du générateur : exemples et référence écrits par un humain, outils déterministes, exécution isolée avec délai.
✍️ À toi, avec aide (10 XP)
Voici une fonction « produite par une IA » :
def mediane(valeurs):
valeurs.sort()
n = len(valeurs)
return valeurs[n // 2]
- Liste au moins quatre défauts ou risques (cas limites, effet de bord, définition de la médiane…).
- Écris les propriétés que tu vérifierais (au moins quatre).
- Écris une implémentation de référence simple (par exemple via
statistics.median) et un test différentiel sur 1 000 entrées aléatoires. - Dis quels défauts le test différentiel détecte et lesquels il faut chercher autrement.
💡 Indice 1
Pour une liste de taille paire, la médiane est la moyenne des deux valeurs centrales.
💡 Indice 2
valeurs.sort() modifie la liste de l'appelant ; liste vide ?
💡 Indice 3
Compare à statistics.median sur des listes d'entiers de tailles variées.
✅ Réponse
import copy, random, statistics
def mediane(valeurs):
valeurs.sort()
n = len(valeurs)
return valeurs[n // 2]
rng = random.Random(1)
echecs = {"liste vide": 0, "entrée modifiée": 0, "différentiel": 0, "borne": 0}
for _ in range(1000):
l = [rng.randint(-5, 5) for _ in range(rng.randint(1, 7))]; copie = copy.deepcopy(l)
r = mediane(l)
if l != copie: echecs["entrée modifiée"] += 1
if r != statistics.median(copie): echecs["différentiel"] += 1
if not min(copie) <= r <= max(copie): echecs["borne"] += 1
try: mediane([]); except_vide = False
except IndexError: except_vide = True
print(echecs, "| liste vide lève IndexError :", except_vide)
echecs[] > echecs[] > echecs[] ==
🚀 À toi, en solo (20 XP)
Vérificateur de références. Un assistant a produit un rapport de 8 références (titre, auteur, année, identifiant) et 6 affirmations chiffrées citant ces références. Tu disposes d'une « base documentaire » locale (dictionnaire) de vraies références avec leur contenu.
- écris
verifier_references(rapport, base): pour chaque référence, existence (identifiant dans la base), cohérence des métadonnées (titre/auteur/année), pour chaque affirmation chiffrée : le chiffre cité apparaît-il dans le contenu de la source citée ? - classe chaque élément :
vérifié,référence inexistante,métadonnées incohérentes,chiffre non retrouvé,source ne soutient pas l'affirmation; - construis un rapport simulé avec des erreurs injectées (2 références inventées, 1 année fausse, 2 chiffres déformés, 1 affirmation attribuée à la mauvaise source) ;
- calcule le rappel de ton vérificateur sur les erreurs injectées et le nombre de faux avertissements ;
- explique ce qu'un vérificateur automatique ne peut pas faire (juger si la source soutient réellement l'affirmation nuancée).
✅ Pistes de correction
import re
BASE = {
"R1": dict(titre="Taux de complétion des cours en ligne", auteur="Martin", annee=2022, contenu="Le taux de complétion moyen est de 12 % pour les cours en ligne ouverts à tous."),
"R2": dict(titre="Effet des rappels sur la rétention", auteur="Durand", annee=2023, contenu="Un rappel par e-mail augmente la reprise de 3 points, de 12 % à 15 %."),
"R3": dict(titre="Pédagogie par projets", auteur="Leroy", annee=2021, contenu="Les apprenants en projet retiennent 40 % de contenu en plus après un mois."),
"R4": dict(titre="Évaluation automatique du code", auteur="Petit", annee=2020, contenu="Les tests automatiques détectent 85 % des erreurs de logique simples."),
}
REFERENCES = [("R1", "Taux de complétion des cours en ligne", "Martin", 2022), ("R2", "Effet des rappels sur la rétention", "Durand", 2021), ("R9", "Les cours du futur", "Inconnu", 2024),
("R3", "Pédagogie par projets", "Leroy", ), (, , , ), (, , , )]
AFFIRMATIONS = [(, ), (, ), (, ),
(, ), (, ), (, )]
(): (re.findall(, t))
():
constats = []
id_, titre, auteur, annee refs:
id_ base: constats.append((id_, ));
b = base[id_]
constats.append((id_, (b[], b[], b[]) == (titre, auteur, annee) ))
texte, source affirmations:
source base: constats.append((texte, ));
manquants = nombres(texte) - nombres(base[source][])
constats.append((texte, manquants ))
manquants ((re.findall(, texte.lower())) & (re.findall(, base[source][].lower()))): constats[-] = (texte, )
constats
c verifier_references(REFERENCES, AFFIRMATIONS, BASE): ()
res = (verifier_references(REFERENCES, AFFIRMATIONS, BASE))
injectees = {: , : , : , : , : , : }
trouvees = ( k, v injectees.items() res.get(k, ).startswith(v))
()
trouvees == (injectees)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Laisser l'IA écrire le code ET ses tests | Les mêmes angles morts dans les deux | Spécification et oracle écrits par un humain, tests indépendants |
| Faire confiance aux exemples fournis | Trois cas qui passent ne prouvent rien | Propriétés aléatoires et test différentiel |
| Ne pas vérifier que les dépendances existent | Imports inventés, API périmées | Analyse statique et exécution réelle |
| Exécuter le code généré sans isolation | Effets de bord, exfiltration | Processus séparé, délai, droits minimaux |
🐉 Mini-boss (40 XP)
Protocole de vérification d'une contribution générée par IA. Définis et implémente un protocole complet pour accepter ou rejeter un correctif proposé par un assistant dans HashBox :
- une spécification écrite (3 comportements, 3 cas limites, 2 erreurs) avant toute génération ;
- un vérificateur automatique : analyse statique (imports existants, appels interdits, secrets, complexité cyclomatique ≤ seuil), exécution isolée avec délai et mémoire limitée, tests d'exemples, propriétés (5), test différentiel contre une référence, mutation de la suite (au moins 15 mutants, score ≥ 85 %) ;
- 8 candidats simulés (2 corrects, 6 défectueux de façons différentes dont une dépendance inventée, un effet de bord, une faille d'injection, une fuite de secret, une lenteur quadratique, un cas limite) ;
- un rapport par candidat avec la raison précise de chaque rejet ;
- une liste de contrôle de revue humaine (10 questions, dont « puis-je expliquer chaque ligne ? ») ;
- la fiche de traçabilité (prompt, modèle, version, date, vérifications passées, relecteur) ;
- les limites du protocole : ce qu'il ne détecte pas, et à quel coût humain.
✅ Pistes de correction
Un bon protocole : spécification d'abord, vérificateur multi-niveaux qui rejette les 6 défectueux pour de bonnes raisons et ne laisse que les 2 corrects en revue humaine, score de mutation de la suite, liste de revue, fiche de traçabilité, et section de limites honnête (par exemple « ne détecte pas une erreur de spécification, ni une faille logique dépendant du contexte métier »).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pourquoi les tests écrits par l'IA pour son propre code sont-ils insuffisants ?
- A. ils sont toujours trop nombreux
- B. ils ne s'exécutent pas
- C. ils partagent ses angles morts : même fausse hypothèse dans le code et le test
2. Un test de propriétés :
- A. vérifie un invariant sur de nombreuses entrées aléatoires
- B. vérifie un seul exemple choisi
- C. remplace la spécification
3. Une dépendance qui n'existe pas dans le code généré est détectée par :
- A. la température du modèle
- B. l'analyse statique : vérifier que les modules importés existent
- C. la longueur du code
4. 🔁 Révision mission 07 : Pour comparer deux systèmes, on évalue de préférence :
- A. chacun sur des cas différents
- B. un seul exemple chacun
- C. les deux sur les mêmes cas, en regardant la différence et son intervalle
5. 🔁 Révision mission 07 : Le kappa de Cohen mesure :
- A. l'accord entre annotateurs au-delà du hasard
- B. la vitesse du modèle
- C. la taille du jeu de test
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quel code généré as-tu déjà intégré sans pouvoir l'expliquer ligne à ligne ?
- Pour quelle partie de ton travail la vérification coûte-t-elle plus que la production ?
🎒 À retenir
- La vérification doit être indépendante de la génération.
- Échelle : spécification, lecture, statique, exemples, propriétés, différentiel, mutation, revue.
- Imports inventés, effets de bord, cas limites, appels dangereux : les défauts typiques.
- Exécuter le code non fiable dans un processus isolé, avec délai.
- Celui qui fusionne répond du code ; garder la compétence de comprendre.
flowchart LR
T(["Vérification humaine et tests"])
T --> R1["1. La vérification doit être indépendante de la génération."]
T --> R2["2. Échelle : spécification, lecture, statique, exemples, propriétés,…"]
T --> R3["3. Imports inventés, effets de bord, cas limites, appels dangereux : les…"]
T --> R4["4. Exécuter le code non fiable dans un processus isolé, avec délai."]
T --> R5["5. Celui qui fusionne répond du code ; garder la compétence de…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Vérificateur impitoyable
← Mission 07 — Évaluation et benchmarks · Mission 09 — Sécurité, confidentialité et gouvernance →
HEF-160 — IA et augmentation humaine

