Meta-prompting : générer des prompts optimaux

Le meta-prompting consiste à utiliser un LLM pour générer ou améliorer des prompts. Au lieu d’écrire manuellement chaque instruction, vous décrivez la tâche et vous demandez au modèle de produire le prompt optimal. Le gain de temps est immédiat, mais le bénéfice le plus intéressant est ailleurs : la technique fait surgir des formulations que vous n’auriez pas envisagées, parce qu’un développeur rédige toujours ses prompts avec les mêmes réflexes et les mêmes angles morts.

Le principe

Un bon prompt est un programme écrit en langage naturel. Comme pour tout programme, il est parfois plus efficace de le générer que de le taper à la main — vous n’écrivez pas non plus vos migrations de base de données caractère par caractère. Le meta-prompting exploite le fait que le modèle a rencontré, pendant son entraînement, une quantité considérable de prompts et de discussions sur ce qui les rend efficaces. L’exemple ci-dessous demande un system prompt de classification de tickets de support. Deux détails méritent votre attention : la spécification est précise jusqu’aux valeurs de catégories, et la dernière ligne impose une sortie brute, sans commentaire d’accompagnement, pour que le résultat soit directement exploitable par le code.

from openai import OpenAI

client = OpenAI()

meta_prompt = """Tu es un expert en prompt engineering.

Génère un system prompt optimisé pour la tâche suivante :
- Objectif : classifier des tickets de support client
- Catégories : bug, feature_request, question, billing
- Sortie : JSON avec "category", "priority" (1-5), "summary"
- Contraintes : réponse en français, max 100 tokens

Le prompt doit inclure :
1. Un rôle clair
2. Les catégories avec des critères de classification
3. Le format de sortie exact avec un exemple
4. Les cas limites (ticket ambigu, hors catégorie)

Retourne UNIQUEMENT le system prompt, sans explication."""

response = client.responses.create(
    model="gpt-5.6-sol",
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Générer à partir de spécifications

Le premier pattern industrialise ce que vous venez de faire à la main : vous décrivez vos exigences sous forme de contraintes fonctionnelles, et le modèle produit le prompt correspondant. En emballant le meta-prompt dans une fonction, vous obtenez un générateur réutilisable pour toutes les tâches de votre application. L’effet de bord est appréciable : les prompts écrits par cinq développeurs différents cessent d’avoir cinq styles différents, ce qui simplifie considérablement leur relecture.

def generer_prompt(objectif: str, contraintes: list[str],
                   format_sortie: str) -> str:
    """Génère un system prompt à partir de spécifications."""
    spec = f"""Génère un system prompt pour cette tâche :

Objectif : {objectif}

Contraintes :
{chr(10).join(f'- {c}' for c in contraintes)}

Format de sortie attendu :
{format_sortie}

Inclus un exemple concret d'entrée/sortie.
Retourne uniquement le prompt, sans commentaire."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=spec,
        temperature=0.5
    )
    return response.output_text

Améliorer un prompt existant

Le deuxième pattern part d’un prompt déjà en service et d’un défaut observé sur le terrain. Plutôt que de le réécrire intégralement, au risque de casser ce qui fonctionnait très bien, vous fournissez le prompt actuel accompagné d’une description précise du problème : « il répond parfois en anglais », « il invente des numéros de commande quand la référence est absente ». La consigne « conserve ce qui fonctionne » constitue ici la partie décisive de l’instruction. Sans elle, le modèle refond spontanément l’ensemble et vous rend un prompt neuf dont vous ne savez plus rien.

def ameliorer_prompt(prompt_actuel: str, probleme: str) -> str:
    """Améliore un prompt existant en fonction d'un retour."""
    meta = f"""Voici un system prompt qui a un problème :

--- PROMPT ACTUEL ---
{prompt_actuel}
--- FIN ---

Problème observé : {probleme}

Réécris ce prompt pour corriger ce problème.
Conserve ce qui fonctionne, modifie uniquement ce qui est nécessaire.
Retourne uniquement le prompt amélioré."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=meta,
        temperature=0.3
    )
    return response.output_text

Produire des variantes à comparer

Le troisième pattern génère plusieurs versions d’un même prompt : objectif constant, mais formulations et structures divergentes. C’est la matière première de l’A/B testing que nous verrons en leçon 15, et sans variantes vous n’avez tout simplement rien à comparer. La température élevée n’est pas une négligence ici : elle sert précisément à obtenir de la diversité entre les versions, là où une température basse vous rendrait trois reformulations quasi identiques.

def generer_variantes(prompt_base: str, n: int = 3) -> list[str]:
    """Génère n variantes d'un prompt."""
    meta = f"""Voici un system prompt :

{prompt_base}

Génère {n} variantes de ce prompt qui :
- Gardent le même objectif
- Utilisent des formulations différentes
- Varient la structure (listes vs paragraphes, ordre des instructions)

Sépare chaque variante par "---VARIANTE---"."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANTE---")

Assembler le pipeline

Les trois briques s’enchaînent naturellement : génération d’un prompt à partir de l’objectif, production de variantes, puis exécution de chaque variante sur un jeu de tests représentatif pour les départager sur pièces plutôt qu’à l’estime.

def pipeline_meta_prompt(objectif: str, tests: list[str]) -> str:
    """Pipeline complet de meta-prompting."""

    # 1. Générer 3 variantes
    variantes = generer_variantes(
        generer_prompt(objectif, [], "texte libre"), n=3
    )

    # 2. Tester chaque variante
    scores = []
    for i, prompt in enumerate(variantes):
        resultats = []
        for test in tests:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=prompt.strip(),
                input=test,
                temperature=0.2
            )
            resultats.append(response.output_text)
        scores.append((i, resultats))

    # 3. Évaluer (à adapter selon vos critères)
    print("Comparez les résultats et sélectionnez la meilleure variante.")
    return variantes, scores

Ce que le meta-prompting ne fera pas pour vous

Le modèle a une nette propension à la sur-optimisation : le prompt qu’il rend arrive souvent trop verbeux, ou trop étroitement calibré sur les exemples que vous avez fournis, au point de mal se comporter sur un cas légèrement différent. La relecture humaine reste donc obligatoire avant tout déploiement, ne serait-ce que pour vérifier qu’aucune règle métier n’a été inventée en chemin — un modèle qui complète une spécification incomplète le fait toujours de bonne foi, et parfois de travers. Surveillez également le coût : chaque itération consomme des tokens, et une boucle d’amélioration sans borne peut tourner longtemps sans jamais converger. Fixez le nombre maximum d’itérations dans le code, pas dans votre discipline personnelle.

Pour vous approprier la technique, prenez une tâche réelle de votre domaine métier, rédigez-en la spécification complète (objectif, contraintes, format), générez trois variantes, éprouvez-les sur cinq cas issus de votre production, puis affinez la meilleure à la main. C’est ce dernier geste manuel, presque toujours, qui fait la différence entre un prompt correct et un prompt que vous êtes prêt à mettre en ligne.

Points clés à retenir

Le meta-prompting utilise le LLM comme générateur de prompts
Trois patterns : génération, amélioration itérative, variantes
Toujours valider le prompt généré avec des tests concrets
Combinez génération automatique et ajustement manuel
Fixez des limites pour éviter les boucles d’itération coûteuses