Prompt Gemini pour expliquer du code : documentation claire et rapide

Vous tombez sur une fonction de 80 lignes sans un seul commentaire, écrite par un collègue parti depuis six mois. Lire le code ligne par ligne fonctionne, mais ça prend du temps et vous risquez de rater des subtilités. Gemini excelle dans l’analyse de code grâce à son entraînement massif sur des dépôts open source — il reconnaît les patterns, les conventions et les cas limites que vous pourriez manquer.

Ce prompt transforme n’importe quel snippet en explication structuree avec documentation inline prête à coller dans votre codebase.

Le prompt

You are a senior software engineer writing documentation for a development team. Analyze the following code and produce a clear, structured explanation.

**Language/Framework**: [LANGUAGE_AND_FRAMEWORK]
**Code to explain**:
[PASTE_YOUR_CODE_HERE]

**Context** (optional): [WHAT_THIS_CODE_IS_PART_OF — e.g. "authentication module", "data pipeline", "API endpoint"]

Produce the following output:

## Overview
A 2-3 sentence summary of what this code does and its role in the system.

## Step-by-Step Walkthrough
Go through the code sequentially. For each logical block (not every single line), explain:
- WHAT it does
- WHY it does it that way
- Any non-obvious behavior or side effects

## Edge Cases & Pitfalls
List any edge cases the code handles (or fails to handle). Flag potential bugs or fragile assumptions.

## Documented Version
Rewrite the original code with clear inline comments. Do not modify the logic — only add documentation comments above functions, complex blocks, and non-obvious lines.

Rules:
- Use plain language, avoid jargon unless the audience is developers
- If the code uses a design pattern (observer, factory, middleware chain, etc.), name it explicitly
- If you spot a potential bug or anti-pattern, flag it with [⚠️ WARNING] and explain why

Comment utiliser ce prompt

Copiez le prompt ci-dessus
Remplacez les variables :
- [LANGUAGE_AND_FRAMEWORK] : le langage et le framework utilises (ex. “Python 3.12 / Django” ou “TypeScript / React 19”)
- [PASTE_YOUR_CODE_HERE] : le bloc de code a analyser — ca peut aller d’une fonction a un fichier entier
- [WHAT_THIS_CODE_IS_PART_OF] : le contexte aide Gemini a comprendre le role du code dans le systeme global (facultatif mais recommande)
Collez dans Gemini (Gemini 2.5 Pro recommande pour les extraits longs ou complexes)
Verifiez la section “Edge Cases” : c’est souvent la ou se cachent les vrais problemes

Exemple de resultat

Entree

Language/Framework: Python 3.12
Code to explain:
def retry(max_attempts=3, delay=1, backoff=2, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempts, current_delay = 0, delay
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    attempts += 1
                    if attempts == max_attempts:
                        raise
                    time.sleep(current_delay)
                    current_delay *= backoff
            return None
        return wrapper
    return decorator

Context: utility module for external API calls

Sortie

Overview Ce decorateur implemente un mecanisme de retry avec backoff exponentiel pour les fonctions qui appellent des services externes. Il intercepte les exceptions specifiees, attend un delai croissant entre chaque tentative, puis relance l’exception si toutes les tentatives echouent.

Step-by-Step Walkthrough

retry(max_attempts, delay, backoff, exceptions) : fonction factory qui retourne un decorateur configure. Le pattern “decorateur avec arguments” necessite trois niveaux d’imbrication (factory > decorator > wrapper).
attempts, current_delay = 0, delay : initialise le compteur et le delai. Le delai est copie pour eviter de modifier le parametre entre appels successifs.
Boucle while attempts < max_attempts : tente l’execution de la fonction. En cas d’exception listee dans exceptions, incremente le compteur, attend current_delay secondes, puis double le delai (current_delay *= backoff).
if attempts == max_attempts: raise : relance la derniere exception sans la masquer. L’appelant recoit l’erreur originale avec sa stack trace intacte.

Edge Cases & Pitfalls

[WARNING] Le return None apres la boucle est du code mort : la boucle se termine soit par un return func(...), soit par un raise. Mais si max_attempts vaut 0, la boucle ne s’execute jamais et la fonction retourne None silencieusement.
Le time.sleep() bloque le thread courant. Dans un contexte async (FastAPI, asyncio), ce decorateur gelerait l’event loop. Il faudrait une variante avec asyncio.sleep().
Le tuple exceptions par defaut intercepte toute Exception, y compris les KeyboardInterrupt dans certaines implementations. A restreindre aux exceptions specifiques (ex. requests.ConnectionError).

Documented Version

def retry(max_attempts=3, delay=1, backoff=2, exceptions=(Exception,)):
    """Decorator: retry a function with exponential backoff on failure.

    Args:
        max_attempts: Maximum number of execution attempts.
        delay: Initial wait time in seconds between retries.
        backoff: Multiplier applied to delay after each failure.
        exceptions: Tuple of exception types that trigger a retry.
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempts, current_delay = 0, delay
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    attempts += 1
                    if attempts == max_attempts:
                        # All retries exhausted — propagate the original exception
                        raise
                    # Wait before next attempt, then increase delay
                    time.sleep(current_delay)
                    current_delay *= backoff
            # Unreachable unless max_attempts <= 0
            return None
        return wrapper
    return decorator

Pourquoi ce prompt fonctionne

Le format de sortie en quatre sections empeche Gemini de produire un pave de texte indigeste. Chaque section a un objectif distinct : vue d’ensemble pour le contexte rapide, walkthrough pour la comprehension profonde, edge cases pour la revue de qualite, et version documentee pour l’integration directe dans le code.

L’instruction de nommer les design patterns active les connaissances techniques de Gemini. Quand le modele identifie un pattern (ici, le decorateur avec arguments), il peut expliquer la structure a un niveau conceptuel au lieu de decrire mecaniquement chaque ligne. Ca accelere la comprehension pour les developpeurs qui connaissent deja le pattern.

Le marqueur [WARNING] pour les bugs potentiels transforme une simple explication en mini-audit de code. Sans cette instruction, Gemini decrit ce que le code fait sans signaler ce qu’il devrait faire. Le flag explicite force le modele a adopter une posture critique, pas seulement descriptive.

Variantes

Pour une revue de code orientee securite

You are a security-focused code reviewer. Analyze the following code for vulnerabilities, insecure patterns, and data exposure risks.

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

For each issue found, provide:
1. **Severity**: Critical / High / Medium / Low
2. **Location**: the specific line or block
3. **Risk**: what could go wrong in production
4. **Fix**: corrected code snippet

If the code is secure, confirm it and explain which good practices are already in place.

Pour generer une docstring/JSDoc complete

You are a technical writer. Generate comprehensive documentation comments for the following code. Use the standard format for the language ([LANGUAGE] — e.g., JSDoc for JavaScript, docstring for Python, XML comments for C#).

**Code**:
[PASTE_YOUR_CODE_HERE]

For each function/method/class, document:
- Purpose (one sentence)
- Parameters with types and descriptions
- Return value with type and description
- Exceptions/errors that can be thrown
- Usage example (one concise example)

Output ONLY the documented code, no explanations outside the comments.

Conseils pour de meilleurs résultats

Limitez la taille du code a une unite logique. Une fonction ou une classe donne de meilleurs résultats qu’un fichier entier de 500 lignes. Si le fichier est long, decoupez-le et analysez chaque bloc separement.
Precisez le contexte métier. “Ce code géré les paiements Stripe” produit une explication plus pertinente que le même code sans contexte. Gemini adapté le niveau de détail et les mises en garde en fonction du domaine.
Utilisez Gemini 2.5 Pro pour le code complexe. Les fonctions imbriquees, les generics TypeScript avances ou le code concurrent (goroutines, async/await) sont mieux geres par le modèle le plus puissant. Pour du code simple, Gemini Flash suffit et répond plus vite.