L'IA est un multiplicateur de capacité. Un multiplicateur de zéro donne zéro ; un multiplicateur sans contrôle multiplie aussi les erreurs. Il faut un flux de travail qui garde le jugement humain au centre.
⏱️ Durée : environ 140 minutes · 🎓 Niveau : avancé · 🏅 Badge : Ingénieur augmenté
🎬 L'histoire
Un an après les premiers essais, l'équipe de HashBox fait le bilan. Certaines tâches vont trois fois plus vite : tests de caractérisation, scripts de migration, documentation. D'autres sont plus lentes qu'avant : celles où l'on passait des heures à comprendre une sortie fausse mais convaincante. Un développeur junior, qui ne programme plus qu'avec l'assistant, n'arrive plus à déboguer sans lui. Une fonctionnalité intégrée sans vraie revue a provoqué un incident de facturation.
« L'IA n'est ni un miracle ni un danger en soi, conclut Maya. Elle amplifie ce que l'équipe fait déjà : une bonne pratique va plus vite, une mauvaise pratique va plus vite aussi. Il faut un workflow : où l'on l'emploie, quelles preuves on exige avant d'intégrer, ce qu'on trace, comment on garde et on développe ses compétences — et comment on mesure si ça paie vraiment. »
Dans cette dernière mission du cursus, tu assembles tout : spécification, génération, vérification indépendante, revue, traçabilité, mesure du retour réel, protection des compétences. Tu construis un assistant d'ingénierie avec périmètre, outils autorisés, évaluations, journal et dossier de validation — et tu fais le bilan de tout le parcours HEF.
🎯 Ta mission
À la fin, je serai capable de :
- décrire un workflow assisté par IA : spécifier, générer, vérifier, revue, intégrer, apprendre
- définir des portes de qualité qui empêchent l'intégration d'une sortie non vérifiée
- tracer la provenance de chaque contribution assistée (modèle, prompt, vérifications, relecteur)
- modéliser l'économie réelle : temps gagné, coût de vérification, défauts échappés
- préserver et développer ses compétences face à l'assistance, et décider quand ne pas utiliser l'IA
🧩 Défi d'échauffement (5 XP)
Fais la liste de cinq tâches de ton travail. Pour chacune, note (1 à 5) : à quel point la production est coûteuse pour toi, à quel point vérifier le résultat est bon marché, et à quel point une erreur non détectée serait grave. Dans quel cas l'IA est-elle une excellente idée ? Dans quel cas est-elle risquée ? Et si la tâche est celle qui te fait progresser, que perds-tu en la déléguant ?
💡 Le concept
Le workflow
flowchart LR
S["1. Spécifier (humain)"] --> G["2. Générer (IA)"]
G --> V["3. Vérifier (indépendant)"]
V -->|échec| G
V -->|succès| R["4. Revue humaine"]
R --> I["5. Intégrer + tracer"]
I --> A["6. Mesurer et apprendre"]
A -.-> S
Description du schéma : six étapes en boucle : l'humain spécifie ; l'IA génère ; une vérification indépendante accepte ou renvoie en génération ; une revue humaine valide ; la contribution est intégrée avec traçabilité ; on mesure et on apprend pour améliorer les spécifications suivantes.
| Étape | Qui | Produit | Porte de qualité |
|---|---|---|---|
| Spécifier | humain | comportement attendu, cas limites, contraintes, critères d'acceptation, tests d'acceptation | spécification écrite avant la génération |
| Générer | IA (avec outils autorisés) | proposition de code, de test, de documentation | périmètre respecté, contexte maîtrisé |
| Vérifier | outils + tests indépendants (mission 8) | rapport de vérification | échelle de vérification adaptée à l'enjeu |
| Revue | humain | décision argumentée | le relecteur peut expliquer chaque ligne |
| Intégrer | humain + pipeline | commit avec provenance | CI verte (HEF-120), revue de sécurité si besoin |
Où l'IA excelle, où elle est risquée
| Très adaptée | Prudence | À éviter sans expert |
|---|---|---|
| tests de caractérisation, scripts jetables, transformations de format, documentation, exploration d'options, explication de code existant, revue en complément | logique métier subtile, concurrence, sécurité, performance critique | décisions juridiques / réglementaires, conception de systèmes critiques, tout ce qu'on ne sait pas vérifier |
Critère central : vérifier coûte-t-il bien moins que produire ? Et que coûte une erreur non détectée ?
Les portes de qualité
Aucune contribution assistée ne passe sans :
- spécification écrite et acceptée ;
- tests indépendants de la génération (mission 8) ;
- analyse statique / sécurité (HEF-100) ;
- revue humaine avec explication de la logique ;
- CI verte (HEF-120) ;
- traçabilité : fiche de provenance.
Une porte qui échoue renvoie à l'étape précédente ; elle n'est jamais « contournée pour aller plus vite ».
La traçabilité (provenance)
Pour chaque contribution : identifiant, auteur humain responsable, modèle et version, date, prompt (ou référence), sources fournies, vérifications passées (avec résultats), relecteur, empreinte du code livré. Utilité : enquêter après un incident, auditer, comprendre une dérive, répondre aux obligations (licences, conformité).
L'économie réelle
gain net par tâche = temps_sans_IA − (temps_prompt + temps_vérification + temps_correction) − coût_défauts_échappés
- Si l'IA est correcte avec probabilité
p: le temps de vérification est payé à chaque fois, le temps de correction(1 − p)fois. - Les défauts échappés (non détectés) coûtent cher plus tard : plus la vérification est légère, plus ils s'accumulent.
- Le taux d'acceptation de la première proposition n'est pas le bon indicateur : mesurer le temps de cycle de bout en bout, les défauts découverts après intégration, le coût total par tâche réussie.
Le point d'équilibre : l'IA vaut la peine tant que p dépasse un seuil dépendant du rapport (coût de vérification + correction) / (coût de production).
Compétences, apprentissage, responsabilité
| Risque | Parade |
|---|---|
| Atrophie : on ne sait plus faire | tâches importantes d'abord à la main ; explain-back ; débogage sans IA régulier |
| Sur-confiance : le texte convaincant endort la vigilance | préférer des preuves (tests) à la lecture rapide |
| Compétence de relecture perdue | pratiquer la relecture critique ; relire avec une grille |
| Apprentissage superficiel (débutants) | exiger l'explication ; utiliser l'IA comme tuteur (questions, indices) plutôt que générateur de réponses |
| Responsabilité diluée | un humain nommé répond de chaque changement |
Un principe : ne délègue pas ce que tu veux apprendre ; délègue ce que tu sais vérifier.
Quand ne pas utiliser l'IA
- données réglementées ou secrets non masquables (mission 9) ;
- tâche dont tu ne peux pas vérifier le résultat ;
- tâche à forte exigence de compréhension profonde (pour apprendre) ;
- quand le coût total (spécifier + vérifier) dépasse celui de faire soi-même.
Conventions d'équipe
Un document court : outils autorisés, données autorisées, portes de qualité, modèle de fiche de provenance, rôles de revue, formation, procédure d'incident, indicateurs suivis, revue trimestrielle.
Le cursus HEF en une phrase
Tout le parcours — penser, programmer, structurer, déployer, tester, sécuriser, mesurer, décider — converge ici : utiliser des outils puissants sans déléguer le jugement. Une sortie générée non vérifiée ne constitue pas une preuve de compétence.
🧠 Astuce : à la fin de chaque semaine, relis trois contributions assistées et demande-toi pour chacune : l'aurais-je écrite pareil ? ai-je compris ce que j'ai accepté ? qu'est-ce que j'ai appris ?
🔍 Exemple pas à pas
Problème : simuler un workflow assisté par IA avec portes de qualité et provenance sur 200 tâches, mesurer l'économie réelle (temps gagné, défauts échappés) selon trois politiques de vérification, trouver le point d'équilibre en fonction de la fiabilité de l'IA, et générer les fiches de provenance.
import hashlib, json, random
from dataclasses import dataclass, field, asdict
# ---------------- 1. fiche de provenance ----------------
@dataclass
class Provenance:
tache: str; auteur_humain: str; modele: str; version_modele: str; prompt_ref: str
verifications: dict = field(default_factory=dict); relecteur: str = ""; empreinte: str = ""; statut: str = "en cours"
def empreinte(code): return hashlib.sha256(code.encode()).hexdigest()[:12]
# ---------------- 2. le workflow avec portes ----------------
class Workflow:
PORTES = ["specification", "tests_independants", "analyse_statique", "revue_humaine", "ci"]
def __init__(self): self.journal = []
def integrer(self, prov, code, resultats):
manque = [p for p in self.PORTES if not resultats.get(p)]
prov.verifications = {p: (resultats.get(p)) p .PORTES}
manque: prov.statut =
prov.relecteur prov.relecteur == prov.auteur_humain: prov.statut =
: prov.statut = ; prov.empreinte = empreinte(code)
.journal.append(asdict(prov)); prov.statut
w = Workflow()
ok = w.integrer(Provenance(, , , , , relecteur=), , {p: p Workflow.PORTES})
sans_tests = w.integrer(Provenance(, , , , , relecteur=), , {**{p: p Workflow.PORTES}, : })
auto_revue = w.integrer(Provenance(, , , , , relecteur=), , {p: p Workflow.PORTES})
s (ok, sans_tests, auto_revue): (, s)
ok == sans_tests.startswith() auto_revue.startswith()
():
rng = random.Random(graine); temps = ; echappes = ; cout_defauts =
PARAM = {
: (, ), : (, ), : (, )}
cout_verif, detection = PARAM[politique]
_ (n):
production = rng.uniform(, )
gain = production
temps_ia = + cout_verif
correct = rng.random() < fiabilite
correct:
temps += production - temps_ia
:
rng.random() < detection:
temps += production - (temps_ia + * production)
:
temps += production - temps_ia; echappes += ; cout_defauts += rng.uniform(, )
temps / , echappes, cout_defauts /
()
nets = {}
fiab (, , ):
pol (, , ):
t, e, c = simuler(pol, fiab); nets[(fiab, pol)] = t - c
()
nets[(, )] > nets[(, )]
nets[(, )] > nets[(, )]
():
t, e, c = simuler(politique, fiabilite, n=, graine=); t - c
seuil = ((p / p (, , ) gain_net(p / ) > ), )
()
seuil <= seuil <=
(, (gain_net(, ), ), , (gain_net(), ), )
():
raisons = []
tache[]: raisons.append()
tache[]: raisons.append()
tache[]: raisons.append()
tache[] >= tache[]: raisons.append()
( raisons), raisons []
t ({: , : , : , : , : , : },
{: , : , : , : , : , : },
{: , : , : , : , : , : }):
()
doit_utiliser_ia({: , : , : , : , : })[]
Lecture :
- Le workflow refuse l'intégration d'une contribution dont une porte n'est pas passée (ici, absence de tests indépendants) ou dont le relecteur est aussi l'auteur humain. Chaque contribution acceptée reçoit sa fiche de provenance avec l'empreinte du code.
- L'économie réelle montre que le gain dépend de la fiabilité de l'IA et de la politique de vérification. Avec une IA à 60 %, ne pas vérifier est désastreux : les défauts échappés coûtent plus que ce qu'on a gagné. Avec une IA à 95 %, dans cette simulation, la vérification lourde coûte plus qu'elle ne rapporte — mais c'est justement cette fiabilité qu'il faut mesurer avant de la supposer (mission 7).
- Le point d'équilibre donne la fiabilité minimale à partir de laquelle l'IA vaut la peine pour cette tâche et cette vérification.
- La règle de décision écrit explicitement quand ne pas utiliser l'IA : données réglementées, résultat non vérifiable, tâche d'apprentissage, vérification aussi coûteuse que la production.
✍️ À toi, avec aide (10 XP)
Une équipe mesure sur 50 tâches assistées :
- temps moyen sans IA : 60 minutes ;
- temps moyen pour rédiger le prompt : 6 minutes ;
- temps moyen de vérification : 14 minutes ;
- 80 % des propositions sont correctes ; pour les 20 % incorrectes, correction en 25 minutes de plus ;
- 4 défauts échappés sur 50 tâches, qui ont coûté chacun en moyenne 3 heures de correction plus tard.
- Calcule le temps moyen par tâche avec l'IA (hors défauts échappés), puis le gain moyen par tâche.
- Intègre le coût des défauts échappés : quel est le gain net moyen par tâche ?
- Si l'on passait à une vérification de 24 minutes qui ne laisse échapper que 1 défaut sur 50 : le gain net est-il meilleur ?
- À partir de quelle durée de vérification (avec 4 défauts échappés) le gain devient-il nul ?
💡 Indice 1
Temps IA = prompt + vérification + 20 % × correction.
💡 Indice 2
Coût des défauts par tâche = (4 × 180 minutes) / 50.
💡 Indice 3
Avec la vérification plus longue : 24 minutes et 1 défaut.
✅ Réponse
sans_ia = 60
def temps_ia(verif): return 6 + verif + 0.20 * 25
def gain_net(verif, defauts): return sans_ia - temps_ia(verif) - defauts * 180 / 50
print(f"vérification 14 min : temps {temps_ia(14):.1f} min, gain brut {sans_ia - temps_ia(14):.1f}, gain net {gain_net(14, 4):.1f} min")
print(f"vérification 24 min : temps {temps_ia(24):.1f} min, gain net {gain_net(24, 1):.1f} min")
verif_nulle = next(v for v in range(1, 120) if gain_net(v, 4) <= 0)
print("gain nul à partir d'une vérification de", verif_nulle, "minutes")
assert round(temps_ia(), ) == (gain_net(, ), ) == gain_net(, ) > gain_net(, )
🚀 À toi, en solo (20 XP)
Simulateur d'organisation assistée par IA. Simule une équipe de 6 personnes sur 12 mois (1 pas = 1 semaine, 10 tâches par personne et par semaine tirées au hasard avec graine fixée) :
- chaque tâche a un coût de production, un coût de vérification, une gravité d'erreur ; l'IA a une fiabilité qui dépend du type de tâche (par exemple 95 % documentation, 85 % tests, 65 % logique métier, 55 % performance) ;
- politique A : « toujours utiliser l'IA, vérifier légèrement » ; politique B : « utiliser l'IA selon la règle de décision de la mission (vérifiable, coût de vérif < production, pas d'apprentissage), vérifier selon la gravité » ; politique C : « jamais d'IA » ;
- chaque personne a un niveau de compétence qui progresse avec la pratique manuelle et s'érode avec l'usage excessif sans pratique (paramètres à définir) ; une compétence basse réduit la capacité à détecter les erreurs ;
- mesure sur 12 mois : tâches terminées, heures économisées, défauts échappés et leur coût, compétence moyenne finale, coût total de possession ;
- cherche le paramétrage de la politique B qui maximise le gain net sans que la compétence moyenne passe sous 70 % du niveau initial ;
- synthèse chiffrée et recommandation d'équipe (règles, formation, indicateurs).
✅ Pistes de correction
import random
FIABILITE = {"documentation": 0.95, "tests": 0.85, "metier": 0.65, "performance": 0.55}
class Personne:
def __init__(self): self.competence = 1.0
def detection(self): return min(0.97, 0.45 + 0.5 * self.competence)
def tache(rng):
t = rng.choice(list(FIABILITE)); prod = rng.uniform(30, 120)
return dict(type=t, prod=prod, verif=prod * (0.25 if t in ("documentation", "tests") else 0.6), gravite=rng.choice([1, 1, 2, 5]), apprentissage=rng.random() < 0.1)
def utiliser():
politique == :
politique == :
t[] < t[] * t[] FIABILITE[t[]] >=
():
rng = random.Random(graine); equipe = [Personne() _ (personnes)]
heures = defauts = ; cout_def = ; faites =
_ (semaines):
p equipe:
utilisations =
_ ():
t = tache(rng); faites +=
utiliser(politique, t):
utilisations +=
verif = t[] * ( politique == effort_verif * ( + * t[]))
det = p.detection() * ( politique == )
rng.random() < FIABILITE[t[]]: heures += (t[] - - verif) /
rng.random() < det: heures += (t[] - - verif - * t[]) /
: heures += (t[] - - verif) / ; defauts += ; cout_def += t[] * rng.uniform(, )
manuel = - utilisations
p.competence = (, (, p.competence + * manuel - * (, utilisations - )))
comp = (p.competence p equipe) / (equipe)
(faites=faites, heures=heures, defauts=defauts, cout_defauts=cout_def, net=heures - cout_def, competence=comp)
pol :
r = simuler(pol); ()
res = {p: simuler(p) p }
res[][] > res[][] res[][] < <= res[][]
meilleur = (((e, simuler(, effort_verif=e)) e (, , , , )), key= x: x[][] x[][] >= -)
()
meilleur[][] >=
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Intégrer parce que « ça a l'air bon » | Défauts échappés, incidents | Portes de qualité : spécification, tests indépendants, revue, CI |
| Mesurer seulement le temps gagné à la production | On ignore vérification et défauts échappés | Gain net de bout en bout |
| Déléguer ce qu'on veut apprendre | Atrophie des compétences | Faire d'abord à la main, IA comme tuteur |
| Pas de traçabilité | Impossible d'enquêter ou d'auditer | Fiche de provenance par contribution |
🐉 Mini-boss (60 XP)
Projet final HEF : l'assistant d'ingénierie de HashBox, avec dossier de validation. Conçois et implémente un assistant d'ingénierie (modèle simulé ou scripté) qui aide à corriger des défauts dans un petit projet, en réunissant les acquis du module et du cursus :
- périmètre explicite (tâches permises / interdites, données autorisées par classification) et outils autorisés (schémas, rôles, plafonds, approbation) — missions 5 et 9 ;
- harnais d'agent : budgets, stagnation, lecture seule des mesures, approbation, instantanés, retour arrière, trace — mission 6 ;
- contexte : budget, faits épinglés, récupération documentaire avec citations et refus — missions 3 et 4 ;
- prompts versionnés, schémas de sortie, banc de régression — mission 2 ;
- vérification indépendante de chaque proposition : analyse statique, tests d'exemples, propriétés, différentiel, mutation — mission 8 ;
- évaluation : jeu de 30 tâches, exécutions multiples, intervalles, comparaison appariée de deux versions, contamination — mission 7 ;
- sécurité : masquage, souillure, assainissement, banc d'attaques avec règle d'acceptation — mission 9 ;
- workflow : portes de qualité, fiche de provenance, journal chaîné — mission 10 ;
- économie : gain net mesuré et point d'équilibre ;
- dossier de validation (5 pages) : ce qui est démontré, ce qui ne l'est pas, risques résiduels, plan de surveillance, règles d'usage, responsable ;
- bilan personnel (20 lignes) : les trois idées du cursus HEF qui ont le plus changé ta façon de travailler, une habitude à garder, une à abandonner, et la prochaine spécialisation HashCode que tu veux explorer.
✅ Pistes de correction
Un excellent projet : l'assistant est borné par un périmètre et des outils explicites, chaque proposition passe par une chaîne de vérification indépendante avant revue humaine, les évaluations ont des intervalles et une règle de décision écrite avant, le banc d'attaques ne montre aucune réussite pour la configuration finale, chaque contribution a une fiche de provenance et un journal chaîné, l'économie est chiffrée, le dossier de validation est honnête sur ce qui n'est pas prouvé, et le bilan personnel relie les idées du cursus (penser en preuves, mesurer avant d'optimiser, concevoir pour la panne, sécuriser par construction, décider sur l'avenir) à une pratique concrète.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Une contribution assistée par IA peut être intégrée seulement si :
- A. elle a passé des vérifications indépendantes et une revue humaine, avec traçabilité
- B. l'IA affirme qu'elle est correcte
- C. elle est rapide à produire
2. Le gain net réel d'un assistant se calcule en tenant compte :
- A. uniquement du temps de génération
- B. du temps de prompt, de vérification, de correction et du coût des défauts échappés
- C. du nombre de lignes produites
3. Pour préserver ses compétences face à l'assistance, on :
- A. délègue tout par principe
- B. évite de relire le code
- C. fait d'abord à la main ce qu'on veut apprendre et sait expliquer ce qu'on accepte
4. 🔁 Révision mission 09 : L'injection de prompt indirecte est une attaque où :
- A. des instructions cachées dans une donnée lue par le système cherchent à le détourner
- B. l'utilisateur écrit lui-même une consigne hostile
- C. le serveur est saturé de requêtes
5. 🔁 Révision mission 09 : La défense la plus solide contre l'exfiltration par un agent est de :
- A. écrire un prompt plus long
- B. casser au moins un côté de la triade (données privées, contenu non fiable, canal externe)
- C. augmenter la température
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle tâche de ton travail devrais-tu continuer à faire à la main pour rester compétent·e ?
- Quelle règle d'équipe écrirais-tu demain pour que « ça passe les tests de l'IA » ne soit jamais un critère d'acceptation suffisant ?
🎒 À retenir
- Spécifier, générer, vérifier (indépendamment), revue humaine, intégrer avec traçabilité, apprendre.
- Portes de qualité non négociables ; fiche de provenance par contribution.
- Gain net = temps gagné − vérification − correction − défauts échappés.
- Ne pas déléguer ce qu'on veut apprendre ; déléguer ce qu'on sait vérifier.
- L'IA multiplie les capacités, jamais la responsabilité : celui qui intègre répond du résultat.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Ingénieur augmenté
← Mission 09 — Sécurité, confidentialité et gouvernance
🎉 Félicitations
Tu as terminé HEF-160 — IA et augmentation humaine, et avec lui le tronc commun HashCode Engineering Foundations. Tu sais comprendre les limites d'un modèle, structurer prompts et contexte, construire un RAG qui cite ou refuse, borner des outils et des agents, évaluer avec rigueur, vérifier de façon indépendante le code généré, défendre un système contre l'injection, et intégrer l'IA dans un workflow où le jugement humain reste au centre.
Du premier raisonnement logique à l'assistant gouverné, le fil est le même : penser en preuves, mesurer avant d'optimiser, concevoir pour la panne, sécuriser par construction, décider honnêtement.
→ Et maintenant : choisis une spécialisation HashCode et applique ces fondations à un vrai projet. 🚀
HEF-160 — IA et augmentation humaine

