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

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 demandez au modèle de produire le prompt optimal pour une tâche donnée. C’est une technique puissante pour accélérer le développement et découvrir des formulations que vous n’auriez pas envisagées.

Le principe

Un bon prompt est un programme en langage naturel. Comme pour tout programme, il est parfois plus efficace de le générer automatiquement que de l’écrire à la main. Le meta-prompting exploite la capacité du modèle à comprendre ce qui rend un prompt efficace.

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.4",
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Patterns de meta-prompting

Génération à partir de spécifications

Décrivez les exigences en termes de contraintes fonctionnelles, et le modèle produit le prompt :

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.4",
        input=spec,
        temperature=0.5
    )
    return response.output_text

Amélioration itérative

Donnez un prompt existant et un feedback, le modèle l’améliore :

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.4",
        input=meta,
        temperature=0.3
    )
    return response.output_text

Génération de variantes

Produisez plusieurs versions d’un prompt pour les comparer (utile pour l’A/B testing que nous verrons en leçon 15) :

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.4",
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANTE---")

Pipeline complet

Voici un pipeline qui génère, teste et sélectionne le meilleur prompt :

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.3",
                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

Limites du meta-prompting

• Le modèle peut sur-optimiser : un prompt généré peut être trop verbeux ou trop spécifique
• Validation humaine indispensable : relisez toujours le prompt généré avant de le déployer
• Coût supplémentaire : chaque itération consomme des tokens
• Boucle infinie : fixez un nombre maximum d’itérations d’amélioration

Mise en pratique

1. Choisissez une tâche de votre domaine métier
2. Écrivez les spécifications (objectif, contraintes, format)
3. Utilisez le meta-prompting pour générer 3 variantes
4. Testez chaque variante avec 5 cas réels
5. Sélectionnez la meilleure et affinez-la manuellement

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