0Pricing
AI Prompt Engineering · Leçon

Comparer les invites vagues et précises

Examinez des exemples côte à côte montrant l’effet spectaculaire de la précision.

Comparer les invites vagues et précises est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 4 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.

Méthode de comparaison côte à côte

La manière la plus rapide d’assimiler la qualité d’une consigne consiste à étudier des réécritures précises côte à côte et à analyser pourquoi chaque amélioration est efficace.

Dans cette leçon, nous examinons cinq consignes vagues et leurs réécritures précises. Pour chaque paire, nous identifions les changements exacts effectués et le mécanisme par lequel chaque amélioration guide le modèle vers un meilleur résultat.

Paire 1 : L’article de blog

Vague : « Rédigez un article de blog sur le travail à distance. »

Précise : « Rédigez un article de blog de 600 mots intitulé “Les 3 habitudes de travail à distance qui ont anéanti ma productivité (et ce que je fais maintenant)” pour une audience de développeurs logiciels de niveau intermédiaire. Voix à la première personne, ton conversationnel. Structure : 1 paragraphe d’introduction, 3 sections avec des titres H2, 1 CTA final invitant à télécharger un modèle gratuit. »

Pourquoi cela fonctionne : ajoute le nombre de mots, le titre (et donc l’angle), l’audience, la voix, le ton, la structure et un élément final précis. Aucune dimension n’est laissée au hasard.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=800,
    messages=[{
        'role': 'user',
        'content': (
            'Write a 600-word blog post titled '
            '"The 3 Remote Work Habits That Killed My Productivity (And What I Do Now)" '
            'for an audience of mid-level software developers. '
            'First-person voice, conversational tone. '
            'Structure: 1-paragraph intro, 3 H2 sections (one per habit), '
            '1 closing paragraph with a CTA to download a free productivity template.'
        )
    }]
)
print(response.content[0].text[:400], '...')

Paire 2 : La revue de code

Vague : « Relisez mon code. »

Précise : « Relisez la fonction Python suivante. Concentrez-vous uniquement sur : 1) les erreurs de correction, 2) les cas limites non gérés. NOT : ne commentez pas le style, le nommage ou la mise en forme. Format du résultat : liste numérotée des problèmes, chacun comprenant : description du problème (1 phrase), ligne(s) concernée(s), correction suggérée (extrait de code). »

Pourquoi cela fonctionne : définit le périmètre de la revue (correction + cas limites), exclut explicitement les autres dimensions (style et nommage) et précise une structure de résultat avec trois champs par constat.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

code = (
    'def get_user(users, user_id):\n'
    '    for user in users:\n'
    '        if user["id"] == user_id:\n'
    '            return user["name"]\n'
    '    return users[0]["name"]\n'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Review the following Python function.\n'
            'Focus ONLY on: 1) correctness bugs, 2) unhandled edge cases.\n'
            'Do NOT comment on style, naming conventions, or formatting.\n'
            'Output format: numbered list. Each item: issue (1 sentence), '
            'affected line, suggested fix as a code snippet.\n\n'
            + code
        )
    }]
)
print(response.choices[0].message.content)

Paire 3 : L’objet de l’e-mail

Vague : « Rédigez des objets d’e-mail pour ma lettre d’information. »

Précise : « Rédigez 10 objets d’e-mail pour une lettre d’information hebdomadaire sur Python destinée aux spécialistes des données. Chaque objet doit comporter moins de 50 caractères, contenir une accroche favorisant l’ouverture (écart de curiosité, liste numérotée ou affirmation surprenante) et éviter les mots déclencheurs de spam comme FREE ou URGENT. Présentez le résultat sous forme de liste numérotée, en indiquant le type d’accroche entre crochets. »

Pourquoi cela fonctionne : précise la quantité, la contrainte de longueur, l’exigence concernant l’accroche, la liste d’exclusions et le format de résultat étiqueté — transformant une tâche créative vague en tâche de génération fondée sur des règles.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Write 10 email subject lines for a weekly newsletter '
            'about Python tips for data scientists. '
            'Requirements:\n'
            '- Each under 50 characters\n'
            '- Must use one of these hooks: [CURIOSITY GAP], [NUMBER], or [SURPRISING CLAIM]\n'
            '- No spam words: FREE, URGENT, ACT NOW, LIMITED TIME\n'
            '- Output as numbered list with hook type in brackets at the end of each line'
        )
    }]
)
print(response.content[0].text)

Paire 4 : Le résumé de réunion

Vague : « Résumez cette transcription de réunion. »

Précise : « Résumez cette transcription de réunion en utilisant le format suivant : 1) Objectif de la réunion (1 phrase), 2) Décisions clés prises (liste à puces, 5 au maximum), 3) Actions à mener (tableau avec les colonnes : Tâche, Responsable, Échéance), 4) Questions ouvertes (liste numérotée). Si une information manque pour un champ, écrivez N/D. N’incluez aucune opinion — uniquement des faits et des engagements. »

Pourquoi cela fonctionne : fournit un modèle exact, précise les limites de chaque section, définit la structure du tableau, prévoit une solution de repli pour les données manquantes et ajoute une contrainte de ton (uniquement les faits).

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

transcript = (
    'John: We need to decide on the launch date. '
    'Sarah: I think Q3 works. We need the API done first. '
    'John: Agreed. Sarah, can you own the API? '
    'Sarah: Yes, I can have it by July 15th. '
    'John: Great. Who handles marketing? '
    'Mike: I will, but I need the feature list first. '
    'John: We still need to confirm pricing — tabled for next week.'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Summarize this meeting transcript in this exact format:\n'
            '1. Meeting Purpose: (1 sentence)\n'
            '2. Key Decisions: (bullet list, max 5)\n'
            '3. Action Items: (markdown table: Task | Owner | Deadline)\n'
            '4. Open Questions: (numbered list)\n'
            'Missing info: write N/A. Facts only, no opinions.\n\n'
            'Transcript:\n' + transcript
        )
    }]
)
print(response.choices[0].message.content)

Paire 5 : L’explication

Vague : « Expliquez l’apprentissage automatique. »

Précise : « Expliquez l’apprentissage automatique en 3 paragraphes à un responsable produit d’une entreprise de santé qui comprend les statistiques, mais n’a jamais programmé. Paragraphe 1 : ce que c’est et en quoi cela diffère de la programmation traditionnelle. Paragraphe 2 : un exemple concret dans le domaine de la santé (diagnostic ou découverte de médicaments). Paragraphe 3 : une idée fausse courante à éviter. 200 mots au maximum au total. »

Pourquoi cela fonctionne : définit la structure (3 paragraphes avec des sujets attribués), l’audience (rôle, domaine et connaissances précises), les exigences de contenu de chaque paragraphe et une limite globale de mots.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=350,
    messages=[{
        'role': 'user',
        'content': (
            'Explain machine learning in exactly 3 paragraphs. '
            'Audience: a product manager at a healthcare company who understands statistics '
            'but has never written code.\n'
            'Paragraph 1: what ML is and how it differs from traditional programming.\n'
            'Paragraph 2: a specific real-world healthcare example (diagnosis or drug discovery).\n'
            'Paragraph 3: one common misconception non-technical people have about ML.\n'
            'Max 200 words total. No bullet points — flowing prose only.'
        )
    }]
)
print(response.content[0].text)

Anatomie d’une bonne réécriture

En observant les cinq paires, on constate que toutes les réécritures efficaces suivent les mêmes principes :

  1. Remplace un verbe vague (« rédiger », « relire », « expliquer ») par une tâche structurée
  2. Nomme le format du résultat (liste, tableau, paragraphes avec un contenu attribué)
  3. Ajoute des contraintes mesurables (nombre de mots, nombre d’éléments, limites de caractères)
  4. Précise l’audience (rôle + connaissances + contexte)
  5. Ajoute au moins une règle d’exclusion (ce qu’il faut omettre)
# Pattern extractor: identify improvements between two prompts
def analyze_improvement(vague, specific):
    improvements = []
    words = specific.lower()
    if any(str(n) in words for n in range(10, 10000)):
        improvements.append('Quantitative constraint added')
    if 'do not' in words or 'exclude' in words or 'avoid' in words or 'no ' in words:
        improvements.append('Negative constraint added')
    if 'audience' in words or 'for a' in words or 'targeting' in words:
        improvements.append('Audience specified')
    if 'format:' in words or 'table' in words or 'list' in words or 'paragraph' in words:
        improvements.append('Output format defined')
    if 'example' in words or 'such as' in words or 'like:' in words:
        improvements.append('Example provided')
    print('Improvements detected:')
    for i in improvements:
        print(f'  + {i}')

vague = 'Write a blog post about remote work.'
specific = 'Write a 600-word blog post for mid-level developers with 3 H2 sections and a closing CTA. No bullet points. Avoid generic productivity advice.'
analyze_improvement(vague, specific)

Ce qui se passe lorsqu’une seule dimension est ajoutée

Ajouter une seule amélioration aide — mais une précision partielle laisse encore de grandes lacunes. Comparez :

  • « Rédigez un article de blog sur le travail à distance » — aucune contrainte
  • « Rédigez un article de blog de 600 mots sur le travail à distance » — uniquement la longueur ; l’angle, l’audience et la structure restent vagues
  • « Rédigez un article de blog de 600 mots sur le travail à distance pour des développeurs, avec un ton conversationnel » — longueur + audience + ton ; la structure, le CTA et le style des titres restent vagues

Chaque dimension que vous laissez indéfinie revient à jouer à pile ou face. Ajoutez-en autant que vos informations le permettent.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Progressively more specific prompts
prompts = [
    'Write about Python.',
    'Write a 200-word article about Python.',
    'Write a 200-word article about Python for beginners who know no programming.',
    (
        'Write a 200-word article about Python for beginners who know no programming. '
        'Start with a real-world analogy. Use 3 short paragraphs. '
        'End with one actionable first step they can take today.'
    )
]

for i, p in enumerate(prompts, 1):
    print(f'Prompt {i} ({len(p)} chars): {p[:80]}...' if len(p) > 80 else f'Prompt {i}: {p}')
    print()

Utiliser concrètement la technique des paires de comparaison

La technique des paires de comparaison est un puissant outil de débogage. Lorsque vous obtenez un mauvais résultat :

  1. Enregistrez la consigne vague qui a produit le mauvais résultat
  2. Identifiez la dimension à l’origine du problème
  3. Rédigez une réécriture précise ciblant uniquement cette dimension
  4. Exécutez les deux consignes et comparez les résultats
  5. Identifiez ce qui doit encore être corrigé, puis ajoutez la contrainte suivante

Cette approche scientifique vous apprend rapidement quelles contraintes comptent le plus pour votre cas d’utilisation.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

def compare_prompts(prompt_a, prompt_b, label_a='A', label_b='B'):
    client_ref = anthropic.Anthropic(api_key='sk-ant-your-key-here')
    for label, prompt in [(label_a, prompt_a), (label_b, prompt_b)]:
        response = client_ref.messages.create(
            model='claude-opus-4-5',
            max_tokens=150,
            messages=[{'role': 'user', 'content': prompt}]
        )
        print(f'=== {label} ===')
        print(prompt)
        print('--- OUTPUT ---')
        print(response.content[0].text)
        print()

compare_prompts(
    prompt_a='Explain APIs.',
    prompt_b='Explain APIs in 3 sentences for a non-technical startup founder. Analogy required.',
    label_a='VAGUE',
    label_b='SPECIFIC'
)

L’audit de deux minutes d’une consigne

Avant d’envoyer toute consigne importante, effectuez cet audit de 2 minutes. Pour chaque question, si la réponse est « non », ajoutez le détail manquant :

  • Le format est-il indiqué ? (liste / tableau / paragraphe / JSON)
  • La longueur est-elle précisée ? (nombre de mots / nombre d’éléments)
  • L’audience est-elle décrite ? (rôle + connaissances)
  • L’objectif est-il clair ? (à quoi sert le résultat)
  • Y a-t-il au moins une exclusion ? (ce qu’il faut omettre)
  • Y a-t-il un exemple ou un modèle ? (si le style est important)
def two_minute_audit(prompt):
    score = 0
    checks = {
        'Format specified': any(w in prompt.lower() for w in
            ['list', 'table', 'paragraph', 'json', 'bullet', 'sentence', 'word']),
        'Length given': any(c.isdigit() for c in prompt),
        'Audience named': any(w in prompt.lower() for w in
            ['for a', 'audience', 'targeting', 'developer', 'manager', 'beginner']),
        'Exclusion added': any(w in prompt.lower() for w in
            ['do not', 'avoid', 'exclude', 'no ', 'without', 'never']),
        'Goal stated': any(w in prompt.lower() for w in
            ['goal', 'purpose', 'so that', 'in order to', 'will be used']),
    }
    print('Prompt Audit:')
    for check, passed in checks.items():
        icon = 'PASS' if passed else 'FAIL'
        print(f'  [{icon}] {check}')
        if passed: score += 1
    print(f'Score: {score}/{len(checks)}')

two_minute_audit(
    'Write 5 bullet-point suggestions for improving user onboarding '
    'for a B2B SaaS app targeting first-time non-technical users. '
    'Avoid suggestions that require engineering work. Each bullet: max 25 words.'
)

Construire votre bibliothèque de prompts

Chaque fois que vous rédigez une consigne qui produit un excellent résultat, enregistrez-la. Construisez une bibliothèque personnelle de consignes, organisée par type de tâche.

Une bonne entrée de bibliothèque comprend :

  • Le modèle de consigne avec des espaces réservés comme [AUDIENCE], [WORD_COUNT]
  • Le cas d’utilisation pour lequel elle a été conçue
  • Le modèle et les paramètres utilisés
  • Une note expliquant son efficacité

Au fil du temps, votre bibliothèque devient votre ressource de productivité liée à l’IA la plus précieuse.

# Example prompt library entry
prompt_library = {
    'meeting_summary': {
        'template': (
            'Summarize the following meeting transcript in this format:\n'
            '1. Purpose: (1 sentence)\n'
            '2. Decisions: (bullet list, max 5)\n'
            '3. Action Items: (table: Task | Owner | Deadline)\n'
            '4. Open Questions: (numbered list)\n'
            'Missing info: N/A. Facts only.\n\nTranscript:\n[TRANSCRIPT]'
        ),
        'use_case': 'Post-meeting automation for Slack or Notion',
        'model': 'claude-opus-4-5',
        'temperature': 0,
        'notes': 'Works best with verbatim transcripts, not paraphrased notes'
    }
}

# Use the template
def run_meeting_summary(transcript):
    template = prompt_library['meeting_summary']['template']
    return template.replace('[TRANSCRIPT]', transcript)

print(run_meeting_summary('Alice: We decided to ship v2 next Friday...')[:200])

Vérification des connaissances

En observant les cinq paires de comparaison de cette leçon, quelle modification unique a amélioré le plus systématiquement la qualité des consignes dans les cinq exemples ?

Vague ou précise — Récapitulatif

Les cinq paires de comparaison révèlent une tendance constante dans ce qui rend les réécritures de consignes efficaces :

  • La structure du résultat est l’amélioration offrant le meilleur ROI — définissez-la toujours
  • Le nombre de mots ou d’éléments élimine entièrement la négociation sur la longueur
  • La description de l’audience calibre automatiquement le vocabulaire et la profondeur
  • Les règles d’exclusion empêchent la production de contenu prévisible de type generic
  • Une précision partielle laisse encore des lacunes — chaque dimension non précisée est une supposition
  • Les bibliothèques de consignes conservent les modèles gagnants pour les réutiliser

Questions Fréquemment Posées

La leçon « Comparer les invites vagues et précises » est-elle gratuite ?

Oui — le texte complet de « Comparer les invites vagues et précises » 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 « Comparer les invites vagues et précises » ?

Examinez des exemples côte à côte montrant l’effet spectaculaire de la précision. 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 4 sur 4.

Combien de temps prend la leçon « Comparer les invites vagues et précises » ?

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

  1. Pourquoi la précision est importante
  2. Éliminer l’ambiguïté des invites
  3. Ajouter des détails concrets
  4. Comparer les invites vagues et précises
← Retour à AI Prompt Engineering