Un bon prompt est une spécification : il dit quoi faire, avec quoi, sous quelles contraintes, dans quel format — et comment on saura que c'est réussi.
⏱️ Durée : environ 105 minutes · 🎓 Niveau : avancé · 🏅 Badge : Rédacteur de consignes
🎬 L'histoire
Maya demande à un assistant : « Fais-moi un résumé de nos retours clients. » Elle obtient dix lignes sympathiques, vagues, inutilisables. Elle reformule : « Voici 40 retours clients [collés]. Rédige un résumé pour la direction (5 lignes max) : les 3 principaux problèmes, avec le nombre de retours concernés, une citation exacte par problème, et une recommandation par problème. N'invente aucun chiffre : si une donnée manque, écris "non disponible". Réponds en JSON avec les clés problemes, citation, recommandation. » Résultat : exploitable, vérifiable, réutilisable.
« La différence, ce n'est pas la politesse ni un mot magique, dit Sam. C'est que la deuxième demande contient une spécification : tâche, contexte, contraintes, format, critère de réussite. Un prompt, c'est une interface. Et comme toute interface, ça se conçoit, ça se teste, ça se versionne. »
Tu apprends à structurer un prompt orienté tâche, à utiliser des exemples (few-shot), à demander un format de sortie strict qu'on peut valider, à gérer les échecs par réparation contrôlée, et à tester tes prompts comme du code.
🎯 Ta mission
À la fin, je serai capable de :
- structurer un prompt (rôle, tâche, contexte, contraintes, format, exemples, critères)
- exiger une sortie structurée et la valider par un schéma, avec une boucle de réparation bornée
- choisir des exemples (few-shot) pertinents et mesurer leur effet
- décomposer une tâche complexe en étapes vérifiables
- tester et versionner des prompts avec des cas de test et un modèle simulé
🧩 Défi d'échauffement (5 XP)
Tu confies une tâche à un nouveau collègue très compétent mais qui ne connaît ni l'entreprise, ni ton projet, ni tes habitudes. Version A : « Occupe-toi du rapport. » Version B : un message qui contient l'objectif, le public, la date limite, les données à utiliser, ce qu'il ne faut pas faire, le format attendu et un exemple de rapport réussi. Dans quel cas tu obtiens le bon résultat du premier coup ? Qu'est-ce que B contient que A n'a pas ?
💡 Le concept
Un prompt est une spécification
Un modèle n'a que ce que contient son contexte. Tout ce que tu sais et qu'il ne sait pas doit y figurer. Les ingrédients d'un bon prompt :
| Élément | Question à laquelle il répond | Exemple |
|---|---|---|
| Rôle / point de vue | qui le modèle doit-il être ? | « Tu es un relecteur de code Python expérimenté. » |
| Tâche | que faut-il produire, précisément ? | « Identifie les failles d'injection SQL dans ce code. » |
| Contexte | quelles informations utiliser ? | le code, la politique, les données |
| Contraintes | quelles règles ? | « N'invente rien. Cite la ligne. Pas de suggestions de style. » |
| Format de sortie | comment présenter ? | tableau, JSON avec clés données |
| Exemples | à quoi ressemble une bonne réponse ? | 1 à 3 paires entrée → sortie |
| Critères de réussite |
Principes
- Spécificité : remplace « un bon résumé » par ses critères.
- Séparer instructions et données : délimiteurs clairs (
<donnees>...</donnees>), surtout pour des contenus non fiables (mission 9). - Dire quoi faire plutôt que quoi ne pas faire (et ajouter les interdits essentiels).
- Autoriser « je ne sais pas » : prévoir la valeur de repli (
null, « non disponible ») pour réduire l'invention. - Demander de citer les passages sources quand l'exactitude compte.
- Une tâche par requête quand c'est possible ; décomposer les tâches complexes en étapes enchaînées avec vérification entre elles.
- Itérer : un prompt se révise comme du code, à partir des échecs observés.
Les exemples (few-shot)
Quelques paires entrée → sortie montrent le format et le ton mieux qu'une longue description.
- choisir des exemples représentatifs et variés, dont un cas limite ;
- les exemples proches de la requête (par similarité) aident davantage que des exemples quelconques ;
- l'ordre peut influencer ; tester.
Sorties structurées
Pour qu'un programme exploite la sortie, exiger un format strict (JSON) et le valider :
- définir un schéma (clés obligatoires, types, valeurs permises) ;
- analyser la sortie et valider ;
- si invalide : réparer — renvoyer au modèle l'erreur précise (« la clé
severitedoit valoirbasse,moyenneouhaute») ; - borner le nombre de tentatives (2 ou 3) puis échouer proprement ;
- ne jamais exécuter ni interpréter sans validation une sortie de modèle.
Beaucoup de fournisseurs offrent un mode « sortie structurée » contraint par un schéma, qui réduit (sans éliminer) les erreurs : la validation reste nécessaire.
Décomposer une tâche
Étape 1 : extraire les faits du texte (liste vérifiable)
Étape 2 : classer chaque fait selon la grille
Étape 3 : rédiger le résumé en n'utilisant que la liste de l'étape 2
Chaque étape produit une sortie vérifiable, ce qui limite la propagation d'erreurs. Le coût : plus d'appels.
Demander un raisonnement
Demander au modèle d'expliciter ses étapes améliore souvent les résultats sur des problèmes à plusieurs étapes, et permet de relire le raisonnement. Mais le raisonnement affiché n'est pas une preuve : il peut être plausible et faux. On vérifie la conclusion, par un calcul ou un test.
Prompts comme du code
| Pratique | Raison |
|---|---|
| Versionner les prompts (dépôt) | traçabilité, revue |
| Cas de test (entrée → critères vérifiables) | détecter les régressions quand on modifie le prompt ou change de modèle |
| Modèles de prompts avec variables validées | pas d'injection accidentelle, pas de variable oubliée |
| Mesurer (taux de réussite sur un jeu) | décider avec des chiffres (mission 7) |
| Linter de prompts | rappeler les éléments manquants |
🧠 Astuce : relis ton prompt en te mettant à la place d'un lecteur compétent qui n'a aucun autre contexte. S'il lui manque une information pour réussir, il manque aussi au modèle.
🔍 Exemple pas à pas
Problème : analyser la qualité d'un prompt avec un « linter », assembler un modèle de prompt avec variables validées, exiger une sortie JSON, la valider contre un schéma avec une boucle de réparation bornée (avec un modèle simulé), choisir des exemples few-shot par similarité, et tester un prompt comme du code.
import json, math, re
from collections import Counter
# ---------------- 1. un « linter » de prompt ----------------
ELEMENTS = {
"tâche": re.compile(r"\b(rédige|résume|identifie|classe|extrais|écris|génère|traduis|corrige|compare|liste)\b", re.I),
"contexte": re.compile(r"<donnees>|\bvoici\b|\bci-dessous\b|\bcontexte\b", re.I),
"contraintes": re.compile(r"\b(n'invente|ne pas|sans|maximum|au plus|uniquement|seulement|exactement)\b", re.I),
"format": re.compile(r"\b(json|tableau|liste à puces|clés?|format|colonnes?)\b", re.I),
"repli": re.compile(r"\b(si .* (manque|absent|inconnu)|non disponible|null|je ne sais pas)\b", re.I),
"critère de réussite": re.compile(r"\b(chaque|doit|vérifiable|cite|citation|avec le nombre)\b", re.I),
}
def linter(prompt):
presents = {nom for nom, motif in ELEMENTS.items() if motif.search(prompt)}
manquants = [n for n in ELEMENTS if n not in presents]
return len(presents) / len(ELEMENTS), manquants
VAGUE = "Fais-moi un résumé de nos retours clients."
PRECIS = ("Voici des retours clients dans <donnees>. Résume-les pour la direction : les 3 principaux problèmes avec le nombre de retours concernés, "
)
nom, p ((, VAGUE), (, PRECIS)):
score, manquants = linter(p); ()
linter(VAGUE)[] < < linter(PRECIS)[]
:
(): .texte, .variables = texte, variables
():
manquantes = (.variables) - (valeurs)
inconnues = (valeurs) - (.variables)
manquantes inconnues: ValueError()
rendu = .texte
k, v valeurs.items(): rendu = rendu.replace( + k + , (v))
rendu
MODELE = ModelePrompt(
, [])
prompt = MODELE.rendre(code=)
prompt
: MODELE.rendre(code=, langue=); AssertionError
ValueError e: (, e)
SCHEMA = {: , : (, , ), : }
():
: donnees = json.loads(texte)
json.JSONDecodeError e: , []
(donnees, ): , []
erreurs = []
i, obj (donnees):
(obj, ): erreurs.append();
cle, attendu SCHEMA.items():
cle obj: erreurs.append()
(attendu, ) obj[cle] attendu: erreurs.append()
(attendu, ) ( (obj[cle], attendu) (obj[cle], )): erreurs.append()
(obj) - (SCHEMA): erreurs.append()
(donnees erreurs ), erreurs
:
(): .reponses, .appels = (reponses), []
():
.appels.append(messages[-]); .reponses.pop()
():
messages = [prompt]
tentative (, max_tentatives + ):
sortie = modele.repondre(messages)
donnees, erreurs = valider(sortie)
donnees : donnees, tentative
messages.append( + .join(erreurs) + )
RuntimeError()
m = ModeleSimule([, , ])
donnees, essais = appeler_avec_reparation(m, prompt)
(, donnees)
(, m.appels[-])
essais == donnees[][] ==
: appeler_avec_reparation(ModeleSimule([] * ), prompt); AssertionError
RuntimeError e: (, (e)[:], )
(): Counter(re.findall(, texte.lower()))
():
num = (a[k] * b[k] k a)
num / ((math.sqrt((v * v v a.values())) * math.sqrt((v * v v b.values()))) )
BANQUE = [(, ), (, ), (, ),
(, ), (, ), (, )]
():
q = sac(requete); (BANQUE, key= ex: -cosinus(q, sac(ex[])))[:k]
choisis = choisir_exemples()
(, [e[] e choisis])
choisis[][] ==
CAS_DE_TEST = [{: , : r: r == []}, {: , : r: (r) == r[][] == }]
():
( cas CAS_DE_TEST ( r: cas[](r))(appeler_avec_reparation(modele_factory(cas[]), MODELE.rendre(code=cas[]))[]))
bon = entree: ModeleSimule([ entree ])
mauvais = entree: ModeleSimule([])
(, executer_tests(bon), , executer_tests(mauvais), )
executer_tests(bon) == executer_tests(mauvais) ==
Lecture :
- Le linter repère les éléments absents : le prompt vague n'a pas de contexte, de contraintes, de format ni de critère ; le prompt précis les contient presque tous. C'est une aide à la relecture, pas une garantie de qualité.
- Le modèle de prompt refuse les variables manquantes ou inconnues : on évite d'envoyer « {code} » littéral ou d'oublier un champ.
- La sortie structurée est validée contre un schéma. Les erreurs précises (« clé
correctionmanquante », «severitedoit valoir basse|moyenne|haute ») sont renvoyées au modèle ; au bout de trois tentatives, on échoue proprement plutôt que de continuer avec une sortie invalide. - Les exemples few-shot sont choisis par similarité avec la requête.
- Les prompts se testent : un jeu de cas avec critères vérifiables détecte un prompt qui invente une faille là où il n'y en a pas.
Le « modèle » ici est un simulateur scripté : il illustre le mécanisme (validation et réparation), pas les performances d'un vrai modèle.
✍️ À toi, avec aide (10 XP)
Voici un prompt faible : « Écris-moi des tests pour cette fonction. »
- Passe-le au linter et note les éléments manquants.
- Réécris-le en un prompt qui précise : le langage et le framework de test, le comportement à couvrir (valeurs limites, erreurs), le format (code seul, noms de tests en français), les contraintes (pas de dépendance au réseau, pas de hasard), un critère de réussite (chaque cas d'erreur documenté testé), et le cas « si le comportement attendu n'est pas clair, pose une question au lieu de deviner ».
- Vérifie que ton nouveau prompt passe le linter à au moins 80 %.
- Écris les trois critères vérifiables par un programme que tu appliquerais à la sortie (par exemple : le code s'exécute, tous les noms de tests commencent par
test_, aucun import réseau).
💡 Indice 1
Utilise la fonction linter de l'exemple.
💡 Indice 2
Un critère vérifiable par programme : ast.parse réussit, nombre de fonctions test_..., absence de requests/socket.
💡 Indice 3
Prévois une valeur de repli.
✅ Réponse
import ast, re
ELEMENTS = {
"tâche": re.compile(r"\b(rédige|résume|identifie|classe|extrais|écris|génère|traduis|corrige|compare|liste)\b", re.I),
"contexte": re.compile(r"<donnees>|\bvoici\b|\bci-dessous\b|\bcontexte\b", re.I),
"contraintes": re.compile(r"\b(n'invente|ne pas|sans|maximum|au plus|uniquement|seulement|exactement)\b", re.I),
"format": re.compile(r"\b(json|tableau|liste à puces|clés?|format|colonnes?)\b", re.I),
"repli": re.compile(r"\b(si .* (manque|absent|inconnu|pas clair)|non disponible|null|je ne sais pas|pose une question)\b", re.I),
"critère de réussite": re.compile(r"\b(chaque|doit|vérifiable|cite|citation|avec le nombre)\b", re.I),
}
def linter(p):
presents = {n for n, m in ELEMENTS.items() if m.search(p)}; return len(presents) / len(ELEMENTS), [n for n in ELEMENTS if n not in presents]
FAIBLE = "Écris-moi des tests pour cette fonction."
BON = ("Écris des tests unitaires pytest pour la fonction ci-dessous, fournie dans <donnees>. Couvre le comportement nominal, les valeurs limites et chaque cas d'erreur documenté. "
"Format : uniquement du code Python, noms de tests en français commençant par test_. Contraintes : sans accès réseau, sans hasard non fixé. "
)
(, linter(FAIBLE)); (, linter(BON))
linter(FAIBLE)[] < linter(BON)[] >=
():
erreurs = []
: arbre = ast.parse(code)
SyntaxError e: []
tests = [n.name n ast.walk(arbre) (n, ast.FunctionDef) n.name.startswith()]
tests: erreurs.append()
imports = {a.name.split()[] n ast.walk(arbre) (n, ast.Import) a n.names} | {n.module.split()[] n ast.walk(arbre) (n, ast.ImportFrom) n.module}
imports & {, , , }: erreurs.append()
(re.fullmatch(, t) t tests): erreurs.append()
erreurs
verifier_sortie() == []
verifier_sortie() verifier_sortie()
()
🚀 À toi, en solo (20 XP)
Banc de régression de prompts. Construis un petit outil pour qualifier un prompt avant de le déployer :
- un jeu de 12 cas de test (entrée, propriétés attendues vérifiables par code) pour une tâche de classification de tickets (« paiement », « compte », « technique », « autre ») ;
- un « modèle simulé » configurable dont le taux d'erreur dépend de trois caractéristiques du prompt : présence d'exemples, présence d'un format strict, présence d'une valeur de repli (tu choisis les effets, par exemple 30 % d'erreurs sans rien, 12 % avec tout), avec une graine fixée ;
- une fonction
evaluer(prompt, n_repetitions=20)qui exécute chaque cas plusieurs fois, valide la sortie par schéma, calcule le taux de réussite et un intervalle de confiance (Wilson) ; - compare 4 variantes du prompt (nu, + exemples, + format, + exemples + format + repli) et décide laquelle déployer avec une règle écrite d'avance (la meilleure dont l'intervalle bas dépasse 85 %) ;
- montre qu'un changement de « modèle » (taux d'erreur différent) détecte une régression avec le même banc.
✅ Pistes de correction
import json, math, random
CAS = [("le paiement a échoué", "paiement"), ("facture incorrecte", "paiement"), ("remboursement refusé", "paiement"), ("mot de passe oublié", "compte"), ("impossible de me connecter", "compte"),
("changer mon adresse e-mail", "compte"), ("la vidéo ne charge pas", "technique"), ("l'application plante", "technique"), ("page blanche au démarrage", "technique"),
("bonjour, merci pour tout", "autre"), ("quel temps fait-il ?", "autre"), ("je voudrais un conseil de carrière", "autre")]
CATEGORIES = ("paiement", "compte", "technique", "autre")
def taux_erreur(prompt):
e = 0.25
if "exemple" in prompt.lower(): e -= 0.08
if "json" in prompt.lower() and "categorie" in prompt.lower(): e -= 0.06
prompt.lower() prompt.lower(): e -=
(e, )
():
rng.random() < taux_erreur(prompt):
faux = rng.choice([c c CATEGORIES c != verite])
json.dumps({: faux}) prompt.lower() rng.random() < faux
json.dumps({: verite}) prompt.lower() verite
():
:
d = json.loads(sortie); d.get() == verite
(json.JSONDecodeError, AttributeError):
sortie.strip() == verite
():
p = s / n; c = (p + z * z / ( * n)) / ( + z * z / n); d = z * math.sqrt(p * ( - p) / n + z * z / ( * n * n)) / ( + z * z / n); c - d, c + d
():
rng = random.Random(graine); ok = total =
_ (n_rep):
entree, verite CAS:
ok += valide(modele_simule(prompt, entree, verite, rng), verite); total +=
ok / total, wilson(ok, total)
VARIANTES = {: , : ,
: ,
: }
()
res = {}
nom, p VARIANTES.items():
taux, (bas, haut) = evaluer(p); res[nom] = (taux, bas, haut); ()
eligibles = [n n, (_, bas, _) res.items() bas >= ]
choix = (eligibles, key= n: res[n][]) eligibles
(, choix)
res[][] < res[][] res[][] >=
taux_avant = evaluer(VARIANTES[])[]
_t = taux_erreur
taux_erreur = p: _t(p) *
taux_apres, (bas_apres, _) = evaluer(VARIANTES[])
taux_erreur = _t
()
bas_apres <
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Prompt vague (« fais un résumé ») | Sortie vague et inutilisable | Spécifier tâche, contexte, contraintes, format, critères |
| Utiliser la sortie d'un modèle sans la valider | Données mal formées, injections, plantages | Schéma, validation, réparation bornée |
| Prompt jamais testé ni versionné | Régressions silencieuses au moindre changement | Cas de test, banc d'évaluation, dépôt |
| Tout demander en une fois | Erreurs qui se propagent sans contrôle | Décomposer en étapes vérifiables |
🐉 Mini-boss (40 XP)
Bibliothèque de prompts de HashBox. Crée une petite bibliothèque de 4 prompts pour des tâches réelles de l'équipe (résumé de retours clients, classification de tickets, extraction d'informations d'un e-mail, revue d'un extrait de code).
- un modèle de prompt par tâche, avec variables validées et délimiteurs pour les données ;
- un schéma de sortie par tâche et une boucle de validation/réparation bornée ;
- 8 cas de test par tâche avec propriétés vérifiables (dont un cas limite et un cas « information absente » où la bonne réponse est le repli) ;
- le linter de prompts appliqué à chacun (score ≥ 80 %) ;
- un banc d'évaluation avec un modèle simulé : taux de réussite, intervalle de Wilson, règle de déploiement écrite d'avance ;
- un journal de versions : pour chaque modification, la raison et l'effet mesuré ;
- un fichier
READMEexpliquant comment ajouter un prompt et comment le qualifier.
✅ Pistes de correction
Un bon travail : 4 modèles avec variables, 4 schémas, boucle de réparation bornée, 32 cas de test, rapport d'évaluation par tâche avec intervalles, règle de déploiement écrite, journal de versions montrant l'effet mesuré de chaque modification (par exemple « ajout d'une valeur de repli : −40 % d'inventions sur les cas limites »), et un README qui impose qu'un prompt sans cas de test ne soit pas intégré.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un bon prompt orienté tâche contient :
- A. uniquement un mot poli
- B. le plus de mots possible
- C. tâche, contexte, contraintes, format de sortie et critères de réussite
2. Avant d'utiliser la sortie JSON d'un modèle dans un programme, il faut :
- A. la valider contre un schéma et gérer l'échec
- B. l'exécuter directement
- C. supposer qu'elle est correcte
3. Pour qualifier un prompt avant déploiement, on :
- A. le relit une fois
- B. l'évalue sur un jeu de cas de test avec un intervalle de confiance
- C. demande l'avis du modèle
4. 🔁 Révision mission 01 : Un modèle de langage produit un texte en :
- A. consultant une base de faits garantie exacte
- B. copiant des pages web en direct
- C. tirant successivement le jeton suivant selon une distribution de probabilités
5. 🔁 Révision mission 01 : Une hallucination est :
- A. une sortie plausible et fluide mais fausse ou non fondée
- B. une erreur de syntaxe
- C. un message de refus
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quel prompt que tu utilises souvent n'a jamais été testé sur plus de deux exemples ?
- Que perdrais-tu si le modèle changeait demain ? Pourrais-tu le détecter ?
🎒 À retenir
- Un prompt est une spécification : tâche, contexte, contraintes, format, exemples, critères, repli.
- Séparer instructions et données ; autoriser « je ne sais pas ».
- Sortie structurée : schéma, validation, réparation bornée.
- Few-shot : exemples représentatifs et proches de la requête.
- Prompts versionnés et testés comme du code (jeu de cas, intervalle, règle de déploiement).
flowchart LR
T(["Prompt engineering orienté tâche"])
T --> R1["1. Un prompt est une spécification : tâche, contexte, contraintes,…"]
T --> R2["2. Séparer instructions et données ; autoriser « je ne sais pas »."]
T --> R3["3. Sortie structurée : schéma, validation, réparation bornée."]
T --> R4["4. Few-shot : exemples représentatifs et proches de la requête."]
T --> R5["5. Prompts versionnés et testés comme du code jeu de cas, intervalle,…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Rédacteur de consignes
← Mission 01 — Modèles génératifs et limites · Mission 03 — Context engineering →
HEF-160 — IA et augmentation humaine

