Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

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

Lekcija 5 od 16 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Meta-prompting : Générer des prompts optimaux
  2. Le principe
  3. Générer à partir de spécifications
  4. Améliorer un prompt existant
  5. Générer des variantes pour comparer
  6. Assembler le pipeline
  7. Ce que le meta-prompting ne fera pas pour toi
  8. Ključne točke

Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI : temperature et top_p ne sont acceptés qu’avec un effort de raisonnement de none, alors que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifier reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Sources : Utilisation de GPT-6 · GPT-5.6 Terra.

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 de rédiger manuellement chaque instruction, tu décris la tâche et tu demandes au modèle de produire le prompt optimal. Le gain de temps est immédiat, mais le véritable bénéfice réside ailleurs : cette technique fait émerger des formulations auxquelles tu n’aurais jamais pensé, car les développeurs écrivent toujours leurs 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 – tu n’écris pas non plus tes migrations de base de données caractère par caractère. Le meta-prompting tire parti du fait que, lors de son entraînement, le modèle a rencontré une vaste quantité de prompts et de discussions sur ce qui les rend efficaces. L’exemple ci-dessous demande un prompt système pour classer des tickets de support. Deux détails méritent ton attention : la spécification est précise jusqu’aux valeurs des catégories, et la dernière ligne impose une sortie brute sans commentaire accompagnateur, garantissant que le résultat est directement exploitable par le code.

from openai import OpenAI

client = OpenAI()

meta_prompt = """You are an expert in prompt engineering.

Generate an optimized system prompt for the following task:
- Objective: Classify customer support tickets
- Categories: bug, feature_request, question, billing
- Output: JSON with "category", "priority" (1-5), "summary"
- Constraints: Response in French, max 100 tokens

The prompt must include:
1. A clear role
2. The categories with classification criteria
3. The exact output format with an example
4. Edge cases (ambiguous ticket, out-of-category)

Return ONLY the system prompt, with no explanation."""

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requires effort none
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Générer à partir de spécifications

Le premier motif industrialise ce que tu viens de faire manuellement : tu décris tes exigences sous forme de contraintes fonctionnelles, et le modèle produit le prompt correspondant. En encapsulant le meta-prompt dans une fonction, tu obtiens un générateur réutilisable pour chaque tâche de ton application. L’effet de bord est significatif : les prompts rédigés par cinq développeurs différents cessent d’avoir cinq styles différents, ce qui simplifie considérablement la revue de code.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Génère un prompt système à partir de spécifications."""
    spec = f"""Generate a system prompt for this task:

Objective: {objective}

Constraints:
{chr(10).join(f'- {c}' for c in constraints)}

Expected output format:
{output_format}

Include a concrete input/output example.
Return only the prompt, with no commentary."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=spec,
        temperature=0.5
    )
    return response.output_text

Améliorer un prompt existant

Le deuxième motif part d’un prompt déjà en production et d’un défaut observé sur le terrain. Au lieu de le réécrire entièrement – ce qui risque de casser ce qui fonctionnait parfaitement –, tu fournis le prompt actuel accompagné d’une description précise du problème : « il répond parfois en anglais » ou « il invente des numéros de commande quand la référence manque ». L’instruction « garde ce qui fonctionne » est ici la partie décisive. Sans elle, le modèle refactorise spontanément l’ensemble et te remet un tout nouveau prompt que tu ne comprends plus.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Améliore un prompt existant basé sur un retour."""
    meta = f"""Here is a system prompt that has a problem:

--- CURRENT PROMPT ---
{current_prompt}
--- END ---

Observed problem: {problem}

Rewrite this prompt to fix this problem.
Keep what works; modify only what is necessary.
Return only the improved prompt."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.3
    )
    return response.output_text

Générer des variantes pour comparer

Le troisième motif génère plusieurs versions du même prompt : objectif constant, mais formulations et structures divergentes. C’est la matière première pour les tests A/B que nous aborderons dans la leçon 15 ; sans variantes, tu n’as tout simplement rien à comparer. La température élevée ici n’est pas un oubli : elle sert précisément à créer de la diversité entre les versions, alors qu’une basse température te donnerait trois reformulations quasi identiques.

def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
    """Génère n variantes d'un prompt."""
    meta = f"""Here is a system prompt:

{base_prompt}

Generate {n} variants of this prompt that:
- Keep the same objective
- Use different phrasing
- Vary the structure (lists vs. paragraphs, order of instructions)

Separate each variant with "---VARIANT---"."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANT---")

Assembler le pipeline

Ces trois briques s’enchaînent naturellement : génère un prompt à partir de l’objectif, produis des variantes, puis exécute chaque variante sur un jeu de tests représentatif pour les juger sur preuves plutôt que sur estimation.

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

    # 1. Générer 3 variantes
    variants = generate_variants(
        generate_prompt(objective, [], "free text"), n=3
    )

    # 2. Tester chaque variante
    scores = []
    for i, prompt in enumerate(variants):
        results = []
        for test in tests:
            response = client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt.strip(),
                input=test,
                temperature=0.2
            )
            results.append(response.output_text)
        scores.append((i, results))

    # 3. Évaluer (à adapter selon tes critères)
    print("Compare les résultats et sélectionne la meilleure variante.")
    return variants, scores

Ce que le meta-prompting ne fera pas pour toi

Le modèle a une forte tendance à la sur-optimisation : le prompt qu’il renvoie est souvent trop verbeux ou trop calibré étroitement sur les exemples que tu as fournis, ce qui le fait mal se comporter sur des cas légèrement différents. Une revue humaine est donc obligatoire avant tout déploiement, ne serait-ce que pour vérifier qu’aucune règle métier n’a été inventée au passage – un modèle complétant une spécification incomplète le fait toujours de bonne foi, et parfois incorrectement. Surveille aussi le coût : chaque itération consomme des tokens, et une boucle d’amélioration sans borne peut tourner longtemps sans jamais converger. Fixe le nombre maximal d’itérations dans ton code, pas dans ta discipline personnelle.

Pour maîtriser cette technique, prends une tâche réelle de ton domaine, écris sa spécification complète (objectif, contraintes, format), génère trois variantes, teste-les sur cinq cas issus de ton environnement de production, puis affine la meilleure à la main. C’est presque toujours cette dernière touche manuelle qui fait la différence entre un prompt correct et un prompt prêt pour la production.

Ključne točke

  • Le meta-prompting utilise le LLM comme générateur de prompts
  • Trois motifs : génération, amélioration itérative, variantes
  • Valide toujours les prompts générés avec des tests concrets
  • Combine génération automatique et ajustement manuel
  • Fixe des limites pour éviter les boucles d’itération coûteuses