Sections d’invite modulaires
Séparez clairement le contexte, les instructions, les contraintes et le format de sortie.
Sections d’invite modulaires est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.
Le problème des prompts monolithiques
Un prompt monolithique entasse tout dans un seul paragraphe : contexte, tâche, règles, exemples et format de sortie sont tous mélangés. À mesure que les prompts gagnent en complexité, une structure monolithique entraîne :
- Les modèles appliquent des règles à la mauvaise section
- Il devient difficile de déterminer quelle partie a causé un résultat incorrect
- Des chaînes de prompts impossibles à maintenir
- Un comportement incohérent entre les versions du modèle
Les prompts modulaires résolvent tous ces problèmes.
Les cinq sections fondamentales d’un prompt
Un prompt bien structuré comporte cinq sections distinctes, chacune ayant un objectif clair :
- Contexte — informations générales dont le modèle a besoin pour comprendre la situation
- Tâche — ce que le modèle must faire, formulé clairement
- Contraintes — règles et limites applicables à la réponse
- Format de sortie — structure, longueur et schéma de la réponse attendue
- Exemples — démonstrations du comportement correct
Tous les prompts n’ont pas besoin des cinq sections. Utilisez seulement ce qui est nécessaire.
Section Contexte
La section Contexte fournit des informations générales sans dire au modèle quoi faire. Un bon contexte comprend :
- Qui est l’utilisateur final
- À quelle plateforme ou à quel produit le contenu est destiné
- Les connaissances pertinentes du domaine
- Tout état antérieur dont le modèle devrait avoir connaissance
context_section = '''
<context>
You are assisting a customer support agent at a B2B SaaS company.
The company sells project management software used by engineering teams.
Customers are typically CTOs, engineering managers, or senior developers.
The support agent is handling a live chat conversation with a customer.
</context>
'''
print(context_section)Section Tâche
La section Tâche indique exactement ce que le modèle doit produire. Elle doit être précise, orientée vers l’action et dépourvue d’éléments de contexte superflus.
task_section = '''
<task>
Draft a response to the customer message below.
The response should:
1. Acknowledge the customer's issue
2. Provide a concrete next step
3. Set a realistic expectation for resolution time
</task>
<customer_message>
Our Gantt chart view stopped loading after the last update.
This is blocking our sprint planning session today.
</customer_message>
'''
print(task_section)Section Contraintes
Les contraintes définissent les garde-fous — ce que le modèle must NOT faire et les limites explicites qu’il doit respecter.
constraints_section = '''
<constraints>
- Do not promise a fix by a specific date unless you are certain.
- Do not mention competitor products by name.
- Keep the response under 100 words.
- Use a professional but empathetic tone.
- Do not ask the customer for information already provided in their message.
</constraints>
'''
print(constraints_section)Section Format de sortie
La section Format de sortie indique exactement au modèle comment structurer sa réponse — schéma JSON, en-têtes Markdown, texte brut, listes numérotées, etc.
output_format_section = '''
<output_format>
Respond with a JSON object containing:
{
"subject": "string (email subject line)",
"body": "string (email body, plain text, under 150 words)",
"priority": "high | medium | low",
"escalate": true | false
}
Do not include any text outside the JSON object.
</output_format>
'''
print(output_format_section)Section Exemples
Les exemples montrent au modèle une paire entrée-sortie correcte. Placez les exemples après les contraintes afin que le modèle voie les règles avant la démonstration.
examples_section = '''
<examples>
<example>
<input>Customer: My invoices are not downloading.</input>
<output>{
"subject": "Invoice Download Issue",
"body": "Thank you for reaching out. We see the issue with invoice downloads and our team is investigating. We expect a fix within 2 hours. We will email you once resolved.",
"priority": "high",
"escalate": true
}</output>
</example>
</examples>
'''
print(examples_section)Assembler un prompt modulaire
L’approche modulaire simplifie l’assemblage et la modification. Chaque section peut être modifiée indépendamment.
def build_support_prompt(customer_message):
context = '<context>B2B SaaS customer support for project management software.</context>'
task = f'<task>Draft a JSON response to this customer message.</task>\n<customer_message>{customer_message}</customer_message>'
constraints = '<constraints>Under 100 words. Professional tone. No competitor names.</constraints>'
output_fmt = '<output_format>Return JSON: {"subject": str, "body": str, "priority": str, "escalate": bool}</output_format>'
return '\n\n'.join([context, task, constraints, output_fmt])
message = 'The Gantt chart stopped loading after your last update.'
print(build_support_prompt(message))Avantages pour la mise au point
Lorsqu’un prompt modulaire produit une sortie incorrecte, vous pouvez isoler la section problématique :
- Mauvaise tâche effectuée ? — Vérifiez la section Tâche
- Une règle a été enfreinte ? — Vérifiez la section Contraintes
- Structure de sortie incorrecte ? — Vérifiez la section Format de sortie
- Qualité insuffisante ? — Vérifiez la section Exemples ou ajoutez davantage de contexte
Vous pouvez modifier une seule section à la fois et faire un nouvel essai sans réécrire tout le prompt.
Avantages pour la maintenance
Les prompts modulaires stockés sous forme d’objets structurés ou de fonctions sont bien plus faciles à maintenir que de longues chaînes littérales :
- Mettez à jour le contexte lorsque votre produit évolue sans toucher à la logique de la tâche
- Remplacez le format de sortie JSON par Markdown sans modifier les contraintes
- Évaluez différents ensembles d’exemples par comparaison A/B en gardant tout le reste constant
- Gérez les versions de chaque section indépendamment
class Prompt:
def __init__(self):
self.context = ''
self.task = ''
self.constraints = []
self.output_format = ''
self.examples = []
def build(self):
parts = []
if self.context:
parts.append(f'<context>\n{self.context}\n</context>')
if self.task:
parts.append(f'<task>\n{self.task}\n</task>')
if self.constraints:
c = '\n'.join(f'- {r}' for r in self.constraints)
parts.append(f'<constraints>\n{c}\n</constraints>')
if self.output_format:
parts.append(f'<output_format>\n{self.output_format}\n</output_format>')
return '\n\n'.join(parts)Quand ignorer certaines sections
Tous les prompts n’ont pas besoin des cinq sections. Suivez ce guide :
- Ignorez le Contexte lorsque la tâche se suffit à elle-même (p. ex. traduire cette phrase)
- Ignorez les Contraintes pour les tâches simples d’extraction sans cas limites
- Ignorez les Exemples lorsque la tâche est directe ou que le modèle la réalise déjà bien sans exemples
- Incluez toujours la Tâche et le Format de sortie — ce sont les sections minimales viables
Préciser excessivement les prompts simples ajoute du bruit sans apporter de bénéfice.
Vérification rapide
Un prompt modulaire produit une structure de sortie incorrecte. Quelle section devez-vous vérifier en premier ?
Sections modulaires — points clés
Les sections modulaires des prompts constituent le fondement d’une ingénierie des prompts facile à maintenir et à mettre au point :
- Cinq sections fondamentales : Contexte, Tâche, Contraintes, Format de sortie, Exemples
- Chaque section a une seule responsabilité — les mélanger crée de la confusion
- La structure modulaire permet une mise au point section par section et des évaluations A/B
- Stockez les prompts sous forme d’objets structurés ou de fonctions, et non de chaînes brutes
- Ignorez les sections inutiles — trop de précisions ajoutent du bruit
- Incluez toujours au moins la Tâche et le Format de sortie dans tout prompt non trivial
Apprends AI Prompt Engineering avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 53
- Leçons
- 199
Questions Fréquemment Posées
La leçon « Sections d’invite modulaires » est-elle gratuite ?
Oui — le texte complet de « Sections d’invite modulaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Sections d’invite modulaires » ?
Séparez clairement le contexte, les instructions, les contraintes et le format de sortie. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?
Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Sections d’invite modulaires » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?
Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Utiliser des balises XML comme délimiteurs
- Sections d’invite modulaires
- Modèle d’invite en-tête-corps-pied de page
- Bonnes pratiques d’organisation des invites