Pourquoi reviewer le code IA
Le code IA a une propriété traître : il a l'air professionnel. La syntaxe est correcte, les noms de variables sont raisonnables, la structure semble logique. C'est exactement ce qui le rend dangereux.
Un code qui a l'air correct ne l'est pas forcément. L'IA ne connait pas votre contexte métier, vos contraintes de performance, ni les conventions de votre équipe. Elle produit du code plausible, pas du code correct.
Traitez le code IA comme le PR d'un développeur junior brillant : techniquement compétent, mais qui ne connait pas encore votre projet.
Le Review Sandwich
La méthode en 3 couches :
- Vous écrivez le code (ou l'IA le génère)
- L'IA review votre code : avec un prompt structuré
- Vous reviewez la review de l'IA : parce que l'IA peut se tromper aussi
Ce que l'IA détecte bien :
- Problèmes de style et conventions
- Bugs évidents (null check manquant, variable non définie)
- Patterns de sécurité connus (XSS, injection SQL)
- Code dupliqué
Ce que l'IA rate souvent :
- Logique métier incorrecte (elle ne connait pas votre domaine)
- Problèmes d'architecture (couplage, responsabilités)
- Performance dans le contexte de votre infrastructure
- Maintenabilité à long terme
Le prompt de review parfait
Ne demandez pas juste "review ce code". Donnez un rôle, des critères et un niveau d'exigence :
Joue le rôle d'un reviewer senior. Sois dur.
Vérifie les critères suivants :
1. Sécurité injections, XSS, CSRF, authentification
2. Performance requêtes N+1, boucles inutiles, mémoire
3. Lisibilité noms, commentaires, complexité
4. Edge cases null, vide, limites, erreurs réseau
La technique adversariale : introduisez volontairement un bug subtil dans le code avant de le soumettre à l'IA. Si elle ne le trouve pas, sa review n'est pas fiable sur ce type de code.
Trouvez les 3 problèmes
Ce code IA gère l'affichage d'une liste d'utilisateurs. Il contient 3 problèmes subtils. Pouvez-vous les trouver ?
<?php
// Afficher les utilisateurs
$query = "SELECT * FROM users WHERE role = '" . $_GET['role'] . "'";
$users = $pdo->query($query)->fetchAll();
foreach ($users as $user) {
echo "<div class='user'>";
echo "<h3>" . $user['name'] . "</h3>";
echo "<p>" . $user['email'] . "</p>";
echo "</div>";
}
?>Réponses :
- Injection SQL (ligne 3) :
$_GET['role']est concaténé directement dans la requête. Solution : requête préparée avec$pdo->prepare() - XSS (lignes 7-8) :
$user['name']et$user['email']ne sont pas échappés. Solution :htmlspecialchars() - Requête N+1 potentielle :
SELECT *charge toutes les colonnes, même inutiles. Et pas deLIMIT: si la table a 100 000 utilisateurs, la page plante
Why review AI code
AI code has a treacherous property: it looks professional. The syntax is correct, variable names are reasonable, the structure seems logical. That is exactly what makes it dangerous.
Code that looks correct is not necessarily correct. The AI does not know your business context, your performance constraints, or your team conventions. It produces plausible code, not correct code.
Treat AI code like the PR of a brilliant junior developer: technically competent, but who does not know your project yet.
The Review Sandwich
The 3-layer method:
- You write the code (or the AI generates it)
- The AI reviews your code — with a structured prompt
- You review the AI's review — because the AI can be wrong too
What AI catches well:
- Style issues and conventions
- Obvious bugs (missing null check, undefined variable)
- Known security patterns (XSS, SQL injection)
- Duplicated code
What AI often misses:
- Incorrect business logic (it does not know your domain)
- Architecture problems (coupling, responsibilities)
- Performance in the context of your infrastructure
- Long-term maintainability
The perfect review prompt
Do not just ask "review this code". Give a role, criteria and a level of rigor:
Act as a senior reviewer. Be strict.
Check the following criteria:
1. Security injections, XSS, CSRF, authentication
2. Performance N+1 queries, useless loops, memory
3. Readability names, comments, complexity
4. Edge cases null, empty, limits, network errors
The adversarial technique: intentionally introduce a subtle bug in the code before submitting it to the AI. If it does not find it, its review is not reliable on that type of code.
Find the 3 problems
This AI code handles displaying a user list. It contains 3 subtle problems. Can you find them?
<?php
// Display users
$query = "SELECT * FROM users WHERE role = '" . $_GET['role'] . "'";
$users = $pdo->query($query)->fetchAll();
foreach ($users as $user) {
echo "<div class='user'>";
echo "<h3>" . $user['name'] . "</h3>";
echo "<p>" . $user['email'] . "</p>";
echo "</div>";
}
?>Answers:
- SQL injection (line 3) —
$_GET['role']is concatenated directly into the query. Solution: prepared statement with$pdo->prepare() - XSS (lines 7-8) —
$user['name']and$user['email']are not escaped. Solution:htmlspecialchars() - Potential N+1 query —
SELECT *loads all columns, even unused ones. And noLIMIT— if the table has 100,000 users, the page crashes
Testez le prompt de review. Collez du code que vous avez écrit récemment et utilisez ce prompt :
Joue le rôle d'un reviewer senior. Sois dur et exigeant. Review le code suivant en vérifiant : 1) Sécurité (injections, XSS, CSRF) 2) Performance (requêtes N+1, boucles inutiles) 3) Lisibilité (noms, commentaires) 4) Edge cases (null, vide, erreurs réseau). Pour chaque problème trouvé, donne la sévérité (critique/moyen/mineur) et la solution. [Collez votre code ici]
Sans relire la leçon : pourquoi faut-il reviewer la review de l'IA, et quel type de problème l'IA rate-t-elle presque toujours ?
Vous êtes le reviewer du code PHP ci-dessus (la liste d'utilisateurs). Rédigez un commentaire de review pour chaque problème trouvé. Mentionnez la sécurité, la validation et la performance.
Tu as soumis le code PHP de la liste d'utilisateurs à l'IA pour review. Voici son verdict. Ton rôle : la 3e couche du Review Sandwich. Acceptes-tu cette review, ou la rejettes-tu ?
Review du code :
- Lisibilite : noms clairs, structure simple. OK.
- XSS : echo de $user['name'] et $user['email'] non echappes.
-> Corriger avec htmlspecialchars().
Verdict : 1 probleme mineur. Code globalement propre,
bon pour la production une fois le XSS corrige.$_GET['role'] concaténé dans la requête), une faille critique, pas mineure. Elle a aussi loupé le SELECT * sans LIMIT. Et elle conclut "bon pour la production" : c'est exactement le faux sentiment de sécurité contre lequel sert la 3e couche. Le XSS qu'elle trouve est réel, mais une review qui rate une injection SQL et la classe "mineure" n'est pas fiable. Tu la rejettes et tu relances avec un prompt qui force la priorité sécurité.Sans remonter dans la leçon : cite deux choses que l'IA review bien et deux qu'elle rate souvent. Et quelle est la technique pour tester si sa review est fiable ?
Une bonne review attrape les défauts visibles, mais les failles de sécurité, elles, restent souvent invisibles. La prochaine leçon, sécuriser le code IA, traque les pièges que l'IA glisse sans le dire : injections, secrets en clair, validations oubliées.
Leçon 8 : Sécuriser le code IA →