Prompt ChatGPT pour le refactoring : améliorez la qualité de votre code existant

Un code qui fonctionne n’est pas forcément un bon code. Les fonctions trop longues, les noms cryptiques et la duplication s’accumulent jusqu’au point où chaque modification prend trois fois plus de temps qu’elle ne devrait. Le refactoring manuel est fastidieux, surtout quand on hésite entre plusieurs approches. Ce prompt donne à ChatGPT un cadre précis pour analyser votre code existant, identifier les problèmes structurels et proposer une version refactorisée avec des justifications concrètes.

Le prompt

You are a senior software architect specializing in clean code and refactoring. I need you to refactor the following code to improve its readability, maintainability, and adherence to best practices.

**Language/Framework**: [LANGUAGE_AND_FRAMEWORK]

**Code to refactor**:
[PASTE_YOUR_CODE]

**What this code does**:
[BRIEF_DESCRIPTION_OF_THE_CODE_PURPOSE]

**Specific concerns** (optional):
[WHAT_BOTHERS_YOU — e.g., "function is too long", "too many nested ifs", "naming is unclear", "hard to test"]

Follow this process:
1. **Code smell analysis** — list every issue you find (naming, structure, duplication, coupling, complexity). Be specific: cite line numbers or function names.
2. **Refactoring plan** — describe each change you will make and why, before writing any code.
3. **Refactored code** — provide the complete rewritten code with comments only where the intent is not obvious from the code itself.
4. **What changed and why** — a bullet list mapping each change to the problem it solves.
5. **Testing notes** — list any edge cases or behaviors that should be verified after this refactoring.

Constraints:
- Preserve the exact same external behavior (inputs, outputs, side effects).
- Do not add new dependencies or frameworks.
- Prefer small, focused functions with clear names over clever one-liners.
- If a change is debatable, mention the trade-off instead of silently choosing one option.

Comment utiliser ce prompt

Copiez le prompt ci-dessus
Remplacez les variables :
- [LANGUAGE_AND_FRAMEWORK] : ex. “Python 3.12 / Django 5” ou “TypeScript / React 19”
- [PASTE_YOUR_CODE] : le code à refactoriser (idéalement une fonction ou un module, pas un projet entier)
- [BRIEF_DESCRIPTION_OF_THE_CODE_PURPOSE] : ce que fait ce code en 1-2 phrases
- [WHAT_BOTHERS_YOU] : vos préoccupations spécifiques (optionnel mais recommandé)
Collez dans ChatGPT (GPT-4o recommandé)
Comparez l’original et le résultat, validez que le comportement est identique avant d’appliquer

Exemple de résultat

Entrée

Language/Framework: TypeScript / Express 5
Code to refactor:
async function handleOrder(req, res) {
  const data = req.body;
  if (data.items && data.items.length > 0) {
    let total = 0;
    for (let i = 0; i < data.items.length; i++) {
      if (data.items[i].price && data.items[i].quantity) {
        total += data.items[i].price * data.items[i].quantity;
        if (data.items[i].discount) {
          total -= data.items[i].discount;
        }
      }
    }
    if (total > 100) {
      total = total * 0.9;
    }
    const order = await db.orders.create({ data: { items: data.items, total: total, userId: data.userId, status: 'pending' } });
    await sendEmail(data.userId, 'Order confirmed', 'Your order #' + order.id + ' total: $' + total);
    res.json({ orderId: order.id, total: total });
  } else {
    res.status(400).json({ error: 'No items' });
  }
}

What this code does: Handles order creation — calculates total, applies discount, saves to DB, sends confirmation email.
Specific concerns: Too many nested ifs, calculation logic mixed with HTTP handling, magic number 0.9.

Sortie

Analyse des code smells :

handleOrder mélange trois responsabilités : validation, calcul métier et persistance
Le seuil de remise (100) et le taux (0.9) sont des magic numbers
Les imbrications if rendent le flux difficile à suivre
Aucune validation du userId
Le calcul de la remise par item est silencieusement ignoré si price ou quantity manquent

Plan de refactoring :

Extraire le calcul du total dans une fonction pure calculateOrderTotal
Extraire les constantes métier
Utiliser un early return pour la validation
Séparer la persistance et la notification

Code refactorisé :

const BULK_DISCOUNT_THRESHOLD = 100;
const BULK_DISCOUNT_RATE = 0.10;

interface OrderItem {
  price: number;
  quantity: number;
  discount?: number;
}

function calculateItemSubtotal(item: OrderItem): number {
  const subtotal = item.price * item.quantity;
  return item.discount ? subtotal - item.discount : subtotal;
}

function calculateOrderTotal(items: OrderItem[]): number {
  const subtotal = items.reduce(
    (sum, item) => sum + calculateItemSubtotal(item),
    0
  );
  if (subtotal > BULK_DISCOUNT_THRESHOLD) {
    return subtotal * (1 - BULK_DISCOUNT_RATE);
  }
  return subtotal;
}

async function handleOrder(req: Request, res: Response) {
  const { items, userId } = req.body;

  if (!items?.length) {
    return res.status(400).json({ error: "No items" });
  }

  const total = calculateOrderTotal(items);
  const order = await db.orders.create({
    data: { items, total, userId, status: "pending" },
  });

  await sendEmail(
    userId,
    "Order confirmed",
    `Your order #${order.id} total: $${total.toFixed(2)}`
  );

  res.json({ orderId: order.id, total });
}

Ce qui a changé :

Magic numbers → constantes nommées (BULK_DISCOUNT_THRESHOLD, BULK_DISCOUNT_RATE)
Calcul extrait dans calculateOrderTotal et calculateItemSubtotal — testables unitairement
Early return pour la validation → plus d’imbrication if/else
Destructuring pour clarifier les données attendues
Template literal au lieu de la concaténation de strings

Notes de test :

Vérifier le calcul avec 0 items, 1 item, plusieurs items
Tester le seuil exact (total = 100, total = 100.01)
Tester les items avec et sans discount

Pourquoi ce prompt fonctionne

L’analyse avant la réécriture force ChatGPT à comprendre le code existant au lieu de le réécrire à l’aveugle. Sans cette étape, le modèle saute souvent directement à une version “propre” qui change subtilement le comportement — un bug classique du refactoring assisté par IA.

La contrainte de préserver le comportement externe est critique. Elle empêche ChatGPT d’ajouter des fonctionnalités non demandées ou de modifier la signature d’une fonction, ce qui casserait le code appelant. Le refactoring concerne la structure interne, pas l’interface.

Demander les trade-offs sur les choix discutables donne un résultat plus honnête. Plutôt qu’un code “parfait” selon un style arbitraire, vous obtenez les options avec leurs avantages et inconvénients, ce qui vous permet de décider selon votre contexte.

Variantes

Pour le refactoring orienté performance

You are a performance-focused software engineer. Refactor the following code to improve its runtime performance while maintaining readability.

**Language/Framework**: [LANGUAGE_AND_FRAMEWORK]
**Code**: [PASTE_YOUR_CODE]
**Performance issue**: [WHAT_IS_SLOW — e.g., "this runs on every request and takes 200ms", "N+1 query problem"]
**Constraints**: [ACCEPTABLE_TRADE_OFFS — e.g., "memory increase OK if it halves execution time"]

For each optimization:
1. Explain the current bottleneck
2. Show the optimized code
3. Estimate the performance improvement and the trade-off involved

Pour le refactoring de code legacy

You are an expert at modernizing legacy codebases. Refactor the following code to use current best practices for [LANGUAGE], while keeping it backward-compatible.

**Code**: [PASTE_LEGACY_CODE]
**Current language version**: [OLD_VERSION]
**Target language version**: [NEW_VERSION]
**Critical constraint**: This code is in production. Changes must be safe and incremental — no full rewrites.

Prioritize changes by risk level (low/medium/high). Start with low-risk modernizations (syntax, naming, simple patterns) before suggesting structural changes.

Conseils pour de meilleurs résultats

Envoyez des blocs de taille raisonnable. Une fonction de 50-150 lignes obtient des résultats bien meilleurs qu’un fichier de 1000 lignes. Si votre fichier est gros, découpez-le en blocs logiques.
Précisez vos préoccupations. “Ce code est nul” ne donne rien d’utile. “Les 3 niveaux d’imbrication rendent la logique difficile à suivre” donne une direction claire au modèle.
Validez le comportement après refactoring. Lancez vos tests existants ou comparez manuellement les sorties. Le refactoring par IA peut introduire des régressions subtiles, surtout sur les cas limites.