Prompt Engineering ChatGPT : code et productivité 2026

Introduction au Prompt Engineering

Qu'est-ce que le Prompt Engineering ?

Le Prompt Engineering consiste à concevoir des instructions claires et structurées pour interagir avec des modèles de langage. Un prompt bien rédigé guide le modèle vers la sortie souhaitée et réduit les itérations nécessaires pour obtenir un résultat exploitable.

Au-delà de la simple question, il s'agit d'apporter contexte, contraintes et exemples — ce qui est essentiel pour des tâches techniques comme la génération de code, la création de tests ou la rédaction de documentation.

• Définition des prompts efficaces.
• Importance de la formulation et du contexte.
• Optimisation des réponses via itérations.
• Utilisation des modèles de langage en production.

Exemple : un prompt minimal peut suffire pour une sortie simple.

echo 'Voici un exemple de prompt'

Cette commande illustre la structure d'une requête courte expédiée vers un système d'IA ou vers un script local.

L'Importance du Prompt Engineering

Un rôle central dans le développement

Le prompt engineering est devenu une compétence transversale : il accélère la création d'exemples, automatise des tâches répétitives et améliore la qualité des livrables. Par exemple, des prompts bien ciblés génèrent des extraits de code immédiatement testables, ce qui réduit le temps passé en corrections mineures.

• Accélération du développement.
• Réduction des erreurs humaines.
• Amélioration de la collaboration inter-équipes.
• Facilitation de l'innovation par prototypage rapide.

Exemple d'appel API (illustration) :

curl -X POST -d 'prompt=Générer un modèle de code' http://api.example.com/generate

La réponse de l'API renverra un bloc de code ou un JSON contenant le résultat généré.

Techniques de Prompting pour la Programmation

Stratégies pour des résultats optimaux

Plusieurs techniques sont efficaces pour obtenir du code de qualité :

1. Découper la tâche en sous-questions (expliquer, puis générer).
2. Préciser l'environnement (langage, framework, versions quand nécessaire).
3. Fournir des exemples d'entrée/sortie (few-shot).
4. Itérer en affinant le prompt et en demandant des tests unitaires.

Exemple : demandez d'abord une explication, ensuite un modèle de code concret.

Voici un exemple Java formaté correctement (HelloWorld).

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, World!");
  }
}

Ce code affiche un message simple en console et sert d'exemple pédagogique pour la structure minimale d'une classe Java.

Comparaison : prompt naïf vs prompt expert

Comparer un prompt minimaliste et un prompt détaillé montre clairement la différence en qualité et en utilité. Ci-dessous, un exemple pratique pour générer une fonction de tri en JavaScript.

Prompt naïf

Prompt: "Écris une fonction qui trie un tableau."

Réponse typique (résumée) : un algorithme simple, parfois non optimisé, sans commentaires ni exemples d'utilisation.

Prompt expert

Le prompt expert fournit le contexte, les contraintes et le format attendu :

Prompt: "Écris une fonction JavaScript nommée quickSort qui trie un tableau d'entiers in-place en utilisant la partition de Lomuto. Ajoute une JSDoc au-dessus de la fonction, indique la complexité temporelle et spatiale, et fournis un exemple d'utilisation."

Réponse attendue : code lisible, testé et documenté. Exemple de sortie générée par un prompt expert :

/**
 * Tri rapide (quicksort) avec partition de Lomuto, tri in-place.
 * Complexité moyenne: O(n log n), pire cas: O(n^2). Espace: O(log n) récursif.
 * @param {number[]} arr
 * @param {number} left
 * @param {number} right
 */
function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left < right) {
    const pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  const pivot = arr[right];
  let i = left;
  for (let j = left; j < right; j++) {
    if (arr[j] <= pivot) {
      [arr[i], arr[j]] = [arr[j], arr[i]];
      i++;
    }
  }
  [arr[i], arr[right]] = [arr[right], arr[i]];
  return i;
}

// Exemple d'utilisation
const nums = [3, 6, 1, 8, 4];
console.log(quickSort(nums));

Le prompt expert fournit une sortie directement exploitable, avec documentation et exemple d'usage — ce qui réduit les allers-retours et les corrections manuelles.

Outils et Ressources pour les Développeurs

Ressources pratiques pour améliorer les workflows

Des IDE comme Visual Studio Code ou IntelliJ IDEA disposent d'extensions d'IA permettant d'intégrer des suggestions et des générations de code directement dans l'éditeur. L'utilisation de templates, CI/CD et linters permet de standardiser les sorties générées automatiquement.

• Visual Studio Code - extensions AI (ex. Copilot, extensions basées sur LSP).
• IntelliJ IDEA - plugins pour intégration d'IA.
• GitHub - CI, templates de projets et actions d'automatisation.
• Jira / Trello - suivi des tâches et intégration avec des bots.

Pour cloner un dépôt depuis GitHub (exemple générique):

git clone <repository-url>

Cette commande crée une copie locale du dépôt pour démarrer le développement.

Modèles et comportement pour le code

Les modèles LLM présentent des comportements différents selon leur architecture et leur optimisation. À titre pratique :

• Certains modèles optimisés pour la latence et la polyvalence (ex. modèles dits "o4"/"4o" selon les providers) offrent des réponses rapides et de haute qualité pour la plupart des tâches de génération.
• Des variantes orientées raisonnement (parfois nommées "o1" ou similaires chez certains fournisseurs) peuvent mieux gérer des chaînes de raisonnement complexes ou des tâches d'analyse, mais elles peuvent être plus lentes ou nécessiter des prompts légèrement adaptés.

Conseil concret : testez vos prompts sur 2-3 variantes (généraliste vs raisonnement) et mesurez les différences sur des métriques simples : exactitude fonctionnelle (tests unitaires), taux d'itération nécessaire, latence et coût. Adaptez la stratégie selon la criticité (p. ex. code productif → privilégier robustesse et vérifications humaines).

Exemple : génération de schéma de base de données (few-shot)

Un bon cas d'usage du few-shot prompting est la génération de schémas ou de structures JSON complexes. Ci-dessous : 1) exemple de prompt few-shot pour demander un schéma relationnel 2) exemple de sortie JSON structurée que le modèle doit produire.

Prompt few-shot (exemple)

Prompt: "Tu es un architecte de données. Génère un schéma SQL PostgreSQL pour une application de gestion de commandes. Contrainte: normalisation 3NF, inclure tables users, products, orders, order_items, et indexs usuels. Fournis le schéma sous forme SQL et un exemple JSON d'un ordre."

Exemples fournis (few-shot):
Input example 1: { 'entity': 'users', 'fields': ['id', 'email', 'name', 'created_at'] }
Output example 1: CREATE TABLE users ( id SERIAL PRIMARY KEY, email VARCHAR(255) UNIQUE, name VARCHAR(150), created_at TIMESTAMP );

Input example 2: { 'entity': 'products', 'fields': ['id', 'sku', 'name', 'price'] }
Output example 2: CREATE TABLE products ( id SERIAL PRIMARY KEY, sku VARCHAR(50) UNIQUE, name VARCHAR(255), price NUMERIC(10,2) );"

Exemple de sortie attendue (format JSON simplifié)

{
  "tables": [
    {
      "name": "users",
      "columns": [
        { "name": "id", "type": "BIGSERIAL", "constraints": ["PRIMARY KEY"] },
        { "name": "email", "type": "VARCHAR(255)", "constraints": ["NOT NULL", "UNIQUE"] },
        { "name": "name", "type": "VARCHAR(150)" },
        { "name": "created_at", "type": "TIMESTAMP", "default": "CURRENT_TIMESTAMP" }
      ]
    },
    {
      "name": "orders",
      "columns": [
        { "name": "id", "type": "BIGSERIAL", "constraints": ["PRIMARY KEY"] },
        { "name": "user_id", "type": "BIGINT", "constraints": ["NOT NULL"] },
        { "name": "status", "type": "VARCHAR(50)" },
        { "name": "total", "type": "NUMERIC(12,2)" }
      ],
      "foreign_keys": [
        { "column": "user_id", "references": "users(id)" }
      ]
    }
  ]
}

Astuce : fournissez au modèle un couple (exemples d'entrée ⇄ sortie) clair pour chaque type d'entité — le few-shot réduit l'ambiguïté et produit un SQL directement exploitable.

Études de Cas

Automatisation de la documentation et support client

Nous avons automatisé la génération de documentation API en temps réel via des prompts structurés, réduisant le travail manuel de mise à jour. De même, l'intégration de l'IA dans le support client a permis de standardiser les réponses et de diminuer les délais de résolution des tickets.

• Documentation automatisée — génération en temps réel.
• Support client — réponses rapides et personnalisées.
• Réduction du temps consacré aux tâches administratives.
• Meilleure allocation des ressources sur les tâches à forte valeur.

Exemple de fonction Python simple utilisée pour prototyper la génération de documentation :

def generate_docs(api):
    """Retourne une description de la documentation pour l'API fournie."""
    return f"Documentation for {api}"

Cette fonction est un point d'entrée minimal pour préparer un prompt qui alimentera un générateur de documents plus complet.

Cycle itératif du prompt engineering

Le prompt engineering est un processus itératif : on envoie un prompt, on évalue la sortie, puis on ajuste le prompt pour améliorer la qualité. Le diagramme ci-dessous illustre ce cycle.

Légende: chaque étape montre le flux de travail (Prompt → Output → Feedback → Refinement). Automatisez les contrôles (tests, lint) entre Output et Feedback pour accélérer les itérations.

Après la génération, automatisez les vérifications (tests unitaires, linting) pour accélérer la boucle d'amélioration.

Cas pratiques et optimisation des flux

Exemples d'intégration en production

Nous avons mis en place des prompts personnalisés pour la génération de README, la création de tests unitaires et la proposition de correctifs de bugs. En combinant des templates de prompts et des checks automatisés (CI), l'équipe a réduit le temps passé sur les tâches répétitives et s'est concentrée sur l'architecture et les nouvelles fonctionnalités.

• Templates de prompts pour tâches courantes (docs, tests, refactors).
• Vérifications automatiques sur chaque sortie (tests, linters).
• Rôles et responsabilités : qui valide, qui intègre.

Exemple simple en JavaScript : fonction d'addition, formatée pour être claire et testable.

function addition(a, b) {
  return a + b;
}

Intégrez ce type de génération dans des hooks de CI pour exécuter des tests automatiquement dès que le code est produit par le modèle.

Sécurité et confidentialité

Quand vous utilisez des modèles de langage en production, la sécurité et la confidentialité des données sont essentielles. Voici des bonnes pratiques concrètes pour limiter les risques liés aux prompts, à la fuite de secrets et aux attaques par prompt injection.

• Ne jamais envoyer de secrets, clés API ou données personnelles sensibles dans un prompt.
• Rédiger et valider automatiquement les prompts pour détecter des patterns sensibles (emails, tokens, chemins locaux).
• Isoler les environnements de test et utiliser des clés API en lecture limitée ou temporaires.
• Mettre en place une validation côté application des sorties issues du modèle (linting, tests unitaires, vérifications de schéma).
• Conserver des logs minimaux et chiffrer les traces contenant des données utilisateur.
• Surveiller les usages pour détecter des requêtes anormales et appliquer des quotas/rate limits.

Mitigation des attaques par prompt injection

Le prompt injection consiste à insérer des instructions malveillantes dans des données fournies au modèle. Pour s'en prémunir :

• Nettoyez et normalisez toutes les entrées utilisateur avant de les inclure dans un prompt.
• Utilisez des templates de prompt avec des sections nommées et insérez les données via un encadrement clair (par ex. marqueurs JSON ou balises fermées).
• Appliquez une politique d'allowlist pour le contenu accepté dans des prompts destinés à des actions sensibles.
• Exécutez des étapes de post-traitement et de vérification sur les sorties (tests unitaires, comparaison d'empreinte, signatures de code).

Exemple : fonction de redaction simple en Python

Exemple pratique pour redacter des tokens/API keys avant d'envoyer les prompts au modèle.

import re
from typing import Pattern

API_KEY_PATTERN: Pattern = re.compile(r"(?:api[_-]?key|secret|token)\s*[:=]\s*[A-Za-z0-9-_]{8,}", re.I)

def redact_sensitive(text: str) -> str:
    """Remplace les occurrences ressemblant à des clés par la chaîne '[REDACTED]'."""
    return API_KEY_PATTERN.sub("[REDACTED]", text)

# Usage
user_input = "Here is my api_key: abcdef12345 and some text."
clean = redact_sensitive(user_input)
print(clean)  # 'Here is my [REDACTED] and some text.'

Cette fonction est volontairement simple. En production, combinez plusieurs règles (patterns, allowlists) et testez-les systématiquement.

Exemple : revue de code automatisée

Voici un prompt type pour demander une revue de code complète, suivie d'un exemple de tests unitaires générés automatiquement (Jest) pour la fonction quickSort présentée plus haut.

Prompt d'exemple (à envoyer au modèle)

Prompt: "Tu es un relecteur de code senior. Analyse le fichier suivant pour détecter bugs, problèmes de performances et suggestions d'amélioration. Donne aussi une suite de tests unitaires Jest qui couvre les cas standards et limites. Format de sortie: 1) Résumé en 3 points 2) Liste des problèmes 3) Tests Jest complets."

Tests unitaires générés (exemple Jest)

const { quickSort } = require('./quickSort');

describe('quickSort', () => {
  test('trie un tableau d'entiers positifs', () => {
    const input = [5, 3, 8, 1, 2];
    expect(quickSort([...input])).toEqual([1, 2, 3, 5, 8]);
  });

  test('gère un tableau déjà trié', () => {
    const input = [1, 2, 3, 4, 5];
    expect(quickSort([...input])).toEqual([1, 2, 3, 4, 5]);
  });

  test('gère des valeurs négatives et les doublons', () => {
    const input = [3, -1, 2, 3, 0];
    expect(quickSort([...input])).toEqual([-1, 0, 2, 3, 3]);
  });

  test('retourne tableau vide pour un tableau vide', () => {
    expect(quickSort([])).toEqual([]);
  });

  test('comporte bien pour un élément unique', () => {
    expect(quickSort([42])).toEqual([42]);
  });
});

Intégrez ces tests dans votre pipeline CI pour valider automatiquement les sorties fournies par le modèle et détecter les régressions.