Prompt ChatGPT pour la revue de code : détectez les bugs avant la mise en production

Les revues de code sont l’une des activités a plus fort levier en développement logiciel, mais aussi l’une des plus difficiles a bien faire. Les reviewers ratent des bugs quand ils sont fatigués, sautent des fichiers quand la PR est volumineuse et se focalisent souvent sur des détails de style au lieu des failles logiques. Ce prompt structure ChatGPT pour relire le code comme le ferait un ingénieur senior rigoureux : en vérifiant les bugs, les failles de sécurité, les problèmes de performance et les soucis de maintenabilité — puis en classant chaque constat par sévérité pour que vous sachiez quoi corriger en priorité.

Le prompt

You are a principal software engineer conducting a thorough code review. Review the following code with the same rigor you would apply to a production pull request at a top tech company.

**Language/Framework**: [LANGUAGE_AND_FRAMEWORK]
**Purpose of this code**: [WHAT_THE_CODE_DOES]
**Context**: [IS_THIS_A_NEW_FEATURE / REFACTOR / BUG_FIX / PROTOTYPE]

**Code to review**:
[PASTE_YOUR_CODE]

Analyze the code across these dimensions, in order of priority:

1. **Correctness** — Are there bugs, logic errors, off-by-one errors, race conditions, or unhandled edge cases?
2. **Security** — Are there injection risks, auth bypasses, data exposure, or unsafe input handling?
3. **Performance** — Are there N+1 queries, unnecessary allocations, blocking operations, or O(n²) algorithms that should be O(n)?
4. **Error handling** — Are failures handled gracefully? Are errors swallowed silently? Are error messages useful for debugging?
5. **Readability** — Is the code clear to someone seeing it for the first time? Are names descriptive? Is the structure logical?
6. **Maintainability** — Will this code be easy to modify in 6 months? Are there hidden dependencies or tight coupling?

For each finding:
- State the issue in one sentence
- Rate severity: 🔴 Critical | 🟡 Warning | 🔵 Suggestion
- Show the specific line(s) affected
- Provide the corrected code

End with a summary: "X critical issues, Y warnings, Z suggestions" and an overall assessment (approve, approve with minor changes, request changes).

Comment utiliser ce prompt

Copiez le prompt ci-dessus
Remplacez les variables :
- [LANGUAGE_AND_FRAMEWORK] : ex. “Go 1.22 / Gin” ou “Python 3.12 / Django 5”
- [WHAT_THE_CODE_DOES] : un résumé en une ligne (ex. : “Handles user authentication and session creation”)
- [IS_THIS_A_NEW_FEATURE / REFACTOR / BUG_FIX / PROTOTYPE] : aide ChatGPT a calibrer ses attentes
- [PASTE_YOUR_CODE] : le code a relire (gardez-le sous 200 lignes pour de meilleurs résultats)
Collez dans ChatGPT (GPT-4o pour la meilleure analyse)
Traitez les points critiques et warnings en priorité, puis considérez les suggestions si le temps le permet

Exemple de résultat

Entrée

Language/Framework: Python 3.12 / Flask
Purpose: API endpoint that creates a new user account
Context: New feature

Code to review:
@app.route("/api/users", methods=["POST"])
def create_user():
    data = request.get_json()
    username = data["username"]
    email = data["email"]
    password = data["password"]

    if User.query.filter_by(email=email).first():
        return jsonify({"error": "Email exists"}), 400

    user = User(username=username, email=email)
    user.password = password
    db.session.add(user)
    db.session.commit()

    return jsonify({"id": user.id, "username": user.username}), 201

Sortie

1. Correctness

Pas de bugs logiques majeurs, mais l’absence de validation des entrées crée de multiples chemins d’échec.

2. Security

🔴 Critique — Mot de passe stocké en clair. user.password = password enregistre le mot de passe brut. Utilisez bcrypt ou argon2 pour le hasher avant stockage.

from werkzeug.security import generate_password_hash
user.password_hash = generate_password_hash(password)

🔴 Critique — Aucune validation des entrées. Si request.get_json() retourne None (mauvais Content-Type) ou s’il manque des clés, l’endpoint lève un TypeError ou KeyError non géré qui expose la stack trace au client.

data = request.get_json(silent=True)
if not data or not all(k in data for k in ("username", "email", "password")):
    return jsonify({"error": "Missing required fields"}), 400

🟡 Warning — Aucune vérification de robustesse du mot de passe. Un utilisateur peut s’inscrire avec le mot de passe “a”. Ajoutez une vérification de longueur minimale (8+ caractères) avant le hachage.

3. Performance

🔵 Suggestion — Unicité du username non vérifiée. Vous vérifiez l’unicité de l’email mais pas du username. Si username a une contrainte d’unicité en base, cela lèvera une IntegrityError au lieu de retourner une réponse 400 propre.

4. Error Handling

🟡 Warning — Pas de try/except autour de db.session.commit(). Une défaillance de la base de données (perte de connexion, violation de contrainte) lèvera une exception non gérée et laissera la session dans un état sale.

try:
    db.session.add(user)
    db.session.commit()
except IntegrityError:
    db.session.rollback()
    return jsonify({"error": "Username or email already taken"}), 409

5. Readability

🔵 Suggestion — L’endpoint fait validation, logique métier et persistance dans une seule fonction. Extraire une fonction create_user_service() rendrait le code plus facile a tester et a réutiliser.

Résumé : 2 problèmes critiques, 2 warnings, 2 suggestions. Verdict : Demande de changements. Le stockage du mot de passe en clair doit etre corrigé avant la mise en production. L’absence de validation des entrées est un problème quasi aussi urgent — elle crée a la fois un risque de sécurité (fuite d’information via les stack traces) et un problème de fiabilité.

Pourquoi ce prompt fonctionne

Le framework a six dimensions (correctness, sécurité, performance, gestion d’erreurs, lisibilité, maintenabilité) reflète la manière dont les reviewers expérimentés pensent réellement. Sans cette structure, ChatGPT a tendance a se focaliser sur les problèmes de style et a manquer les failles de sécurité ou de logique, car le feedback stylistique est plus facile a générer.

Les niveaux de sévérité forcent le modèle a prioriser. Une liste plate de 15 constats est écrasante et donne l’impression que tout est aussi important. Les niveaux critique/warning/suggestion vous indiquent exactement ce qui doit etre corrigé vs ce qui peut attendre.

Exiger le code corrigé pour chaque constat transforme la revue d’une liste de plaintes en un plan d’amélioration actionnable. Cela aide aussi ChatGPT a vérifier ses propres suggestions — s’il ne peut pas écrire la correction, le constat est probablement erroné.

Variantes

Pour une revue de Pull Request (basée sur le diff)

You are a senior engineer reviewing a pull request. I'll show you the diff (added/removed lines). Focus on what changed, not what already existed.

**PR title**: [PR_TITLE]
**PR description**: [PR_DESCRIPTION]

**Diff**:
[PASTE_GIT_DIFF]

Review only the changed lines. For each issue, reference the exact line from the diff. Rate each finding (Critical / Warning / Suggestion). End with an approve/request-changes verdict.

Pour une revue axée sécurité

You are a senior application security engineer. Perform a security-focused code review of the following code.

**Language/Framework**: [LANGUAGE_AND_FRAMEWORK]
**Code**:
[PASTE_CODE]

Check for the OWASP Top 10 categories that apply:
- Injection (SQL, NoSQL, OS command, LDAP)
- Broken authentication or session management
- Sensitive data exposure
- Insecure deserialization
- Security misconfiguration
- Cross-site scripting (XSS)

For each vulnerability found: describe the attack vector, show proof-of-concept input that would exploit it, and provide the secure fix.

Conseils pour de meilleurs résultats

Relisez 100-200 lignes a la fois. Les blocs de code plus longs poussent ChatGPT a survoler et rater des problèmes, exactement comme le ferait un reviewer humain. Découpez les grosses PRs en morceaux logiques.
Précisez le contexte clairement. Un prototype reçoit un feedback différent d’un code de production. Indiquer le contexte a ChatGPT évite les suggestions de sur-ingénierie pour du code jetable.
Demandez une seconde passe après avoir corrigé les problèmes critiques. Dites “I fixed the two critical issues. Here is the updated code — are there any remaining concerns?” pour attraper ce que la première passe a manqué.