Techniques avancées de prompt engineering

Maîtrisez l'art de communiquer avec Claude pour obtenir des résultats optimaux.

Fondamentaux

Anatomie d'un bon prompt

Un prompt efficace contient :

1. Contexte : Qui est Claude dans cette conversation ?
2. Tâche : Que doit-il faire exactement ?
3. Format : Comment structurer la réponse ?
4. Exemples : Montrez ce que vous attendez
5. Contraintes : Limites et règles

Template :

const prompt = `
[Contexte]
Tu es un expert en [domaine] avec 10 ans d'expérience.

[Tâche]
Analyse ce code et identifie les problèmes de performance.

[Format]
Fournis ta réponse sous forme de liste numérotée avec:
- Problème identifié
- Sévérité (faible/moyenne/élevée)
- Solution recommandée

[Code]
${code}

[Contraintes]
- Maximum 5 problèmes
- Focus sur l'impact réel
- Solutions concrètes uniquement
`;

Techniques de prompt

1. Chain of Thought (CoT)

Demandez à Claude de "réfléchir à voix haute" :

const prompt = `Résous ce problème étape par étape:

Problème: Calcule le nombre de serveurs nécessaires pour gérer 1 million d'utilisateurs simultanés.

Réfléchis d'abord aux facteurs à considérer, puis calcule.`;

Pourquoi ça marche : Claude décompose le problème et raisonne mieux.

2. Few-Shot Learning

Donnez des exemples :

const prompt = `Convertis ces descriptions en objets JSON structurés.

Exemple 1:
Input: "iPhone 15 Pro, 256GB, Bleu"
Output: {"product": "iPhone 15 Pro", "storage": "256GB", "color": "Bleu"}

Exemple 2:
Input: "MacBook Air M2, 512GB, Argent"
Output: {"product": "MacBook Air M2", "storage": "512GB", "color": "Argent"}

À toi:
Input: "iPad Pro 12.9, 1TB, Noir"`;

3. Role Prompting

Assignez un rôle spécifique :

system: `Tu es un architecte logiciel senior spécialisé en systèmes distribués.
Tu as travaillé chez Google et Amazon.
Tu privilégies la simplicité et la maintenabilité.`

Rôles efficaces :

• Expert technique (langage, framework)
• Reviewer de code (focus qualité)
• Teacher (explications pédagogiques)
• Debugger (résolution de problèmes)

4. Constraining

Définissez des contraintes claires :

const prompt = `Génère un composant React AVEC:
✅ TypeScript strict
✅ Props validation avec Zod
✅ Tests unitaires
✅ Documentation JSDoc
✅ Gestion d'erreurs

SANS:
❌ any types
❌ console.log
❌ Dépendances externes
❌ Plus de 100 lignes`;

5. Iterative Refinement

Affinez progressivement :

// Prompt 1
"Crée une fonction de tri"

// Prompt 2 (après voir le résultat)
"Améliore cette fonction pour gérer les cas limites: tableaux vides, null, undefined"

// Prompt 3
"Optimise pour les grands tableaux (>10000 éléments)"

// Prompt 4
"Ajoute des tests unitaires complets"

6. Template Prompts

Créez des templates réutilisables :

function codeReviewPrompt(code: string, language: string) {
  return `Tu es un expert en ${language}.

Revue ce code selon ces critères:

1. **Bugs** : Erreurs logiques ou techniques
2. **Performance** : Optimisations possibles
3. **Sécurité** : Vulnérabilités potentielles
4. **Maintenabilité** : Clarté et structure
5. **Best practices** : Respect des conventions

Code:
\`\`\`${language}
${code}
\`\`\`

Pour chaque point, fournis:
- Ligne concernée
- Problème
- Solution
- Impact (faible/moyen/élevé)`;
}

Techniques avancées

XML Tags

Structurez avec des balises XML :

const prompt = `
<context>
Application: E-commerce Next.js
Stack: TypeScript, Prisma, PostgreSQL
Users: 100k+ monthly
</context>

<task>
Optimise cette requête Prisma pour réduire le temps de réponse.
</task>

<current_code>
${code}
</current_code>

<requirements>
- Temps < 100ms
- Pas de N+1 queries
- Cache Redis si nécessaire
</requirements>
`;

Avantages :

• Structure claire
• Parsing facile
• Claude comprend mieux les sections

Multi-turn Conversations

Construisez des conversations sophistiquées :

const conversation = [
  {
    role: 'user',
    content: 'Je veux créer une API REST pour un blog'
  },
  {
    role: 'assistant',
    content: 'Super ! Quelques questions:\n1. Quel framework ?\n2. Base de données ?\n3. Authentification ?'
  },
  {
    role: 'user',
    content: 'Express.js, PostgreSQL, JWT'
  },
  {
    role: 'assistant',
    content: 'Parfait. Voici l'architecture que je propose...'
  },
  {
    role: 'user',
    content: 'Commence par le modèle User'
  }
];

Context Stuffing

Maximisez le contexte utile :

const context = {
  projectStructure: readProjectStructure(),
  relevantFiles: findRelevantFiles(query),
  dependencies: readPackageJson(),
  conventions: readCodingStandards(),
  history: getRecentChanges()
};

const prompt = `
<project_context>
${JSON.stringify(context, null, 2)}
</project_context>

<task>
Ajoute une nouvelle feature: ${feature}
</task>

Respecte la structure existante et les conventions du projet.
`;

Self-Consistency

Demandez plusieurs solutions puis la meilleure :

const prompt = `Propose 3 approches différentes pour résoudre ce problème:

${problem}

Pour chaque approche, fournis:
- Description
- Avantages
- Inconvénients
- Complexité

Ensuite, recommande la meilleure approche et explique pourquoi.`;

Chain of Verification

Demandez à Claude de vérifier son propre travail :

// Étape 1 : Génération
const code = await generateCode(prompt);

// Étape 2 : Vérification
const verification = await client.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  messages: [{
    role: 'user',
    content: `Revue ce code que tu viens de générer:

${code}

Identifie les bugs, problèmes de sécurité ou optimisations possibles.`
  }]
});

// Étape 3 : Correction
if (verification.hasIssues) {
  const fixed = await fixCode(code, verification.issues);
}

Optimisations

Réduire les tokens

Avant (verbose) :

"Peux-tu s'il te plaît analyser ce fichier de code et me dire quels sont les problèmes que tu peux identifier dans ce code, notamment les bugs, les problèmes de performance et tout ce qui pourrait être amélioré ?"

Après (concis) :

"Analyse ce code. Identifie: bugs, problèmes de performance, améliorations possibles."

Économie : ~40% de tokens

Caching intelligent

// Contexte stable (mis en cache)
const system = `Tu es un expert TypeScript.
Conventions du projet:
- Utilise des const par défaut
- camelCase pour variables
- PascalCase pour composants
- Interfaces préfixées par 'I'
...`; // Ce texte sera cachedautomatiquement

// Requêtes multiples réutilisent le cache
await client.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  system,
  messages: [{ role: 'user', content: 'Génère un composant Button' }]
});

await client.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  system, // Réutilise le cache !
  messages: [{ role: 'user', content: 'Génère un composant Card' }]
});

Batch Processing

async function batchAnalyze(files: string[]) {
  // Grouper plusieurs fichiers dans un seul appel
  const prompt = files.map((file, i) => `
<file id="${i}">
<path>${file.path}</path>
<content>
${file.content}
</content>
</file>
  `).join('\n');

  const response = await client.messages.create({
    model: 'claude-sonnet-4-5-20250929',
    messages: [{
      role: 'user',
      content: `Analyse ces ${files.length} fichiers et identifie les patterns communs:\n${prompt}`
    }]
  });

  return parseResponse(response.content[0].text);
}

Patterns de code

Assistant Factory

class ClaudeAssistant {
  constructor(
    private client: Anthropic,
    private system: string,
    private model: string = 'claude-3-5-sonnet-20241022'
  ) {}

  async ask(prompt: string, context?: any): Promise<string> {
    const messages = [{
      role: 'user' as const,
      content: context
        ? `<context>${JSON.stringify(context)}</context>\n\n${prompt}`
        : prompt
    }];

    const response = await this.client.messages.create({
      model: this.model,
      system: this.system,
      max_tokens: 4096,
      messages
    });

    return response.content[0].text;
  }
}

// Usage
const codeReviewer = new ClaudeAssistant(
  client,
  'Tu es un expert en code review. Focus sur bugs et sécurité.'
);

const testWriter = new ClaudeAssistant(
  client,
  'Tu es un expert en tests. Génère des tests complets et significatifs.'
);

Conversation Manager

class ConversationManager {
  private history: Array<{ role: string; content: string }> = [];

  constructor(private client: Anthropic) {}

  async send(message: string): Promise<string> {
    this.history.push({
      role: 'user',
      content: message
    });

    const response = await this.client.messages.create({
      model: 'claude-sonnet-4-5-20250929',
      max_tokens: 2048,
      messages: this.history as any
    });

    const reply = response.content[0].text;

    this.history.push({
      role: 'assistant',
      content: reply
    });

    return reply;
  }

  reset() {
    this.history = [];
  }

  getHistory() {
    return [...this.history];
  }
}

Cas d'usage avancés

Code Generation Pipeline

async function generateFullFeature(description: string) {
  // 1. Planification
  const plan = await claude.ask(`
    Crée un plan détaillé pour cette feature: ${description}

    Inclus:
    - Fichiers à créer
    - Modèles de données
    - APIs endpoints
    - Tests nécessaires
  `);

  // 2. Génération des modèles
  const models = await claude.ask(`
    Basé sur ce plan:
    ${plan}

    Génère les modèles Prisma nécessaires.
  `);

  // 3. Génération des APIs
  const apis = await claude.ask(`
    Avec ces modèles:
    ${models}

    Génère les endpoints Express avec:
    - Validation Zod
    - Error handling
    - TypeScript strict
  `);

  // 4. Génération des tests
  const tests = await claude.ask(`
    Pour ces APIs:
    ${apis}

    Génère les tests Jest avec:
    - Tests unitaires
    - Tests d'intégration
    - Mocks nécessaires
  `);

  return { plan, models, apis, tests };
}

Intelligent Debugging

async function debugWithClaude(error: Error, code: string, context: any) {
  const debugPrompt = `
<error>
${error.stack}
</error>

<code>
${code}
</code>

<context>
- Framework: ${context.framework}
- Node version: ${context.nodeVersion}
- Recent changes: ${context.recentChanges}
</context>

<task>
1. Identifie la cause racine de l'erreur
2. Explique pourquoi ça arrive
3. Propose une solution
4. Fournis le code corrigé
5. Suggère comment éviter ce type d'erreur à l'avenir
</task>
  `;

  return await claude.ask(debugPrompt);
}

Documentation Generator

async function generateDocs(codebase: string[]) {
  const docsPrompt = `
Génère une documentation complète pour ce projet.

<codebase>
${codebase.map(file => `
<file path="${file.path}">
${file.content}
</file>
`).join('\n')}
</codebase>

Structure:
1. Vue d'ensemble
2. Architecture
3. Guide de démarrage
4. API Reference
5. Exemples d'usage
6. FAQ

Format: Markdown
Audience: Développeurs intermédiaires
Ton: Technique mais accessible
  `;

  return await claude.ask(docsPrompt);
}

Debugging de prompts

Problème : Réponses inconsistantes

Solution : Ajoutez de la structure

// ❌ Mauvais
"Analyse ce code"

// ✅ Bon
`Analyse ce code selon cette checklist:
[ ] Bugs
[ ] Performance
[ ] Sécurité
[ ] Maintenabilité

Pour chaque point trouvé, utilise ce format:
### [Catégorie] Titre
**Ligne**: X
**Problème**: Description
**Solution**: Code corrigé`

Problème : Claude refuse la tâche

Solution : Clarifiez le contexte légitime

// ❌ Peut être refusé
"Hack ce système"

// ✅ Contexte clair
`Dans le cadre d'un audit de sécurité autorisé, identifie les vulnérabilités de ce code:`

Problème : Réponses trop longues

Solution : Contraignez explicitement

const prompt = `${task}

CONTRAINTE: Maximum 200 mots.
Si tu dépasses, tu échoues.`;

Meilleures pratiques

✅ DO

• Soyez spécifique et clair
• Donnez des exemples concrets
• Structurez avec XML/Markdown
• Définissez le format de sortie
• Utilisez le system prompt pour le contexte stable
• Testez et itérez vos prompts
• Gardez une bibliothèque de prompts efficaces

❌ DON'T

• Prompts vagues ("fais quelque chose")
• Trop de contexte inutile
• Instructions contradictoires
• Oublier les contraintes
• Négliger les cas limites
• Dupliquer le contexte dans chaque message

Ressources

• Anthropic Prompt Library : docs.anthropic.com/claude/prompts
• Discord CC France : Salon #prompt-engineering
• Examples GitHub : github.com/anthropics/prompt-eng-examples

Prochaines étapes

• 🧪 Testez ces techniques sur vos projets
• 📊 Mesurez l'amélioration des résultats
• 💬 Partagez vos prompts efficaces sur Discord
• 🏆 Participez aux challenges de prompt engineering

Maîtriser le prompt engineering, c'est débloquer 10x la puissance de Claude ! 🚀