Meta-prompting: générer des invites optimales
Op deze pagina
Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.
Meta-prompting : générer des invites optimales
Le meta-prompting consiste à utiliser un LLM pour générer ou améliorer des invites (prompts). Au lieu de rédiger manuellement chaque instruction, vous décrivez la tâche et demandez au modèle de produire l’invite optimale. Le gain de temps est immédiat, mais le véritable avantage réside ailleurs : cette technique fait émerger des formulations auxquelles vous n’auriez jamais pensé, car les développeurs rédigent toujours leurs invites avec les mêmes réflexes et les mêmes angles morts.
Le principe
Une bonne invite 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 caractère par caractère ; vous n’écrivez pas non plus vos migrations de base de données lettre par lettre. Le meta-prompting tire parti du fait que, lors de son entraînement, le modèle a rencontré une vaste quantité d’invites et de discussions sur ce qui les rend efficaces. L’exemple ci-dessous demande une invite système pour classer des tickets de support. Deux détails méritent votre attention : le cahier des charges est précis 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 schéma industrialise ce que vous venez de faire manuellement : vous décrivez vos exigences sous forme de contraintes fonctionnelles et le modèle produit l’invite correspondante. En encapsulant le meta-prompt dans une fonction, vous obtenez un générateur réutilisable pour chaque tâche de votre application. L’effet secondaire est significatif : les invites rédigées 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 une invite 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 une invite existante
Le deuxième schéma part d’une invite déjà en production et d’un défaut observé sur le terrain. Au lieu de la réécrire entièrement — ce qui risque de casser ce qui fonctionnait parfaitement —, vous fournissez l’invite actuelle accompagnée d’une description précise du problème : « elle répond parfois en anglais » ou « elle invente des numéros de commande lorsque la référence est manquante ». L’instruction « conservez ce qui fonctionne » est ici déterminante. Sans elle, le modèle refactorise spontanément l’ensemble et vous remet une toute nouvelle invite que vous ne comprenez plus.
def improve_prompt(current_prompt: str, problem: str) -> str:
"""Améliore une invite existante sur la base de retours."""
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 à comparer
Le troisième schéma génère plusieurs versions de la même invite : 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, vous n’avez 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, tandis qu’une température faible vous donnerait trois reformulations quasi identiques.
def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
"""Génère n variantes d'une invite."""
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érez une invite à partir de l’objectif, produisez des variantes, puis exécutez 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 vos critères)
print("Comparez les résultats et sélectionnez la meilleure variante.")
return variants, scores
Ce que le meta-prompting ne fera pas pour vous
Le modèle a une forte tendance à la sur-optimisation : l’invite qu’il renvoie est souvent trop verbeuse ou trop calibrée sur les exemples que vous avez fournis, ce qui la 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 à tort. Surveillez également le coût : chaque itération consomme des jetons, et une boucle d’amélioration sans borne peut tourner longtemps sans jamais converger. Fixez le nombre maximal d’itérations dans votre code, pas dans votre discipline personnelle.
Pour maîtriser cette technique, prenez une tâche réelle de votre domaine, rédigez son cahier des charges complet (objectif, contraintes, format), générez trois variantes, testez-les sur cinq cas issus de votre environnement de production, puis affinez la meilleure à la main. C’est presque toujours cette dernière touche manuelle qui fait la différence entre une invite correcte et une invite prête pour la production.
Belangrijkste punten
- Le meta-prompting utilise le LLM comme générateur d’invites
- Trois schémas : génération, amélioration itérative, variantes
- Validez toujours les invites générées avec des tests concrets
- Combinez génération automatique et ajustement manuel
- Fixez des limites pour éviter les boucles d’itération coûteuses