Prompt Engineering pour devs : Les patterns qui marchent vraiment
Prompt Engineering pour devs : Les patterns qui marchent vraiment
Bon, soyons honnêtes : tu utilises ChatGPT, Claude ou GitHub Copilot tous les jours. Mais franchement, combien de fois tu te retrouves à reformuler ton prompt 5 fois avant d'obtenir ce que tu veux ?
"Écris-moi une API REST"
→ Résultat générique qui ne compile même pas
"Non attends, écris-moi une API REST avec Express et MongoDB"
→ Mieux, mais toujours pas adapté à ton contexte
"Écoute, voilà mon schéma de données, écris-moi une API REST complète avec..."
→ Ah enfin ! Mais ça t'a pris 10 minutes.
Le problème ? Tu ne connais pas les patterns de prompt engineering.
Et je ne parle pas des "astuces magiques" qu'on voit sur Twitter (X) ou sur Facebook. Je parle des vraies techniques, testées et prouvées par la recherche, qui transforment ta façon d'utiliser l'IA au quotidien.
Dans cet article, je vais te montrer les 3 patterns essentiels que tout développeur devrait maîtriser, avec des exemples concrets tirés de mon workflow de dev Full-Stack MERN.
Prêt à arrêter de galérer avec tes prompts ? Allons-y.
Pourquoi le Prompt Engineering est crucial pour les devs (en 2026)
Regarde, la demande pour les compétences en prompt engineering a explosé de 250% en un an. Et franchement, ce n'est pas pour rien.
En tant que développeur, tu passes probablement 30-50% de ton temps à interagir avec des IA maintenant :
- Générer du code avec GitHub Copilot
- Débugger avec ChatGPT/Claude
- Écrire de la documentation
- Créer des tests unitaires
- Refactorer du code legacy
Le truc ? La différence entre un prompt moyen et un excellent prompt, c'est :
- 3-5x moins de temps à obtenir ce que tu veux
- Du code qui marche du premier coup (ou presque)
- Moins de frustration et plus de productivité
Bon, maintenant qu'on sait pourquoi c'est important, voyons comment faire.
Pattern #1 : Zero-Shot Prompting (pour les tâches simples)
C'est quoi exactement ?
Zero-shot prompting signifie donner une instruction au modèle sans fournir d'exemples. Tu comptes uniquement sur la compréhension innée du modèle.
C'est comme demander à un collègue dev qui connaît déjà le contexte : tu donnes juste l'instruction, sans explications supplémentaires.
Quand l'utiliser ?
- Tâches simples et bien définies
- Questions directes
- Code boilerplate standard
- Quand le modèle connaît déjà le pattern
Exemples concrets pour devs
#### ❌ Mauvais Zero-Shot
Crée une fonctionFranchement, l'IA va te sortir n'importe quoi. Trop vague.
#### ✅ Bon Zero-Shot
Crée une fonction TypeScript qui valide une adresse email.
Elle doit retourner true si l'email est valide, false sinon.
Utilise une regex standard.Résultat attendu :
function isValidEmail(email: string): boolean {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return emailRegex.test(email);
}Cas d'usage réels
1. Générer des types TypeScript
Génère les types TypeScript pour un User avec :
- id (string)
- email (string)
- name (string)
- createdAt (Date)
- roles (tableau de strings)2. Créer des hooks React simples
Crée un hook React personnalisé useLocalStorage qui :
- Prend une clé et une valeur par défaut
- Synchronise avec localStorage
- Retourne [value, setValue] comme useState3. Écrire des tests unitaires basiques
Écris un test Jest pour une fonction calculateTotal(items)
qui additionne les prix d'un tableau d'objets {name, price}.
Teste les cas : tableau vide, un item, plusieurs items.Limites du Zero-Shot
Écoute, Zero-Shot c'est bien pour les trucs simples. Mais dès que ça devient complexe (logique métier spécifique, architecture particulière), l'IA va galérer.
C'est là que Few-Shot entre en jeu.
Pattern #2 : Few-Shot Prompting (pour guider le style)
C'est quoi exactement ?
Few-shot prompting signifie fournir quelques exemples dans le prompt pour guider le modèle vers de meilleures performances. Tu montres 1 à 3 exemples de ce que tu veux, et l'IA comprend le pattern.
C'est comme montrer à un junior comment tu codes : tu lui montres 2-3 exemples, et il capte le style.
Quand l'utiliser ?
- Quand tu veux un style/format spécifique
- Logique métier particulière
- Patterns de code non-standards
- Conventions de ton projet
Exemples concrets pour devs
#### Cas 1 : Générer des API routes avec ton pattern
Prompt Few-Shot :
Voilà comment je structure mes API routes Express :
Exemple 1 :
// GET /api/users/:id
router.get('/users/:id', async (req, res) => {
try {
const user = await User.findById(req.params.id);
if (!user) return res.status(404).json({ error: 'User not found' });
res.json({ data: user });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
Exemple 2 :
// POST /api/users
router.post('/users', async (req, res) => {
try {
const user = await User.create(req.body);
res.status(201).json({ data: user });
} catch (error) {
res.status(400).json({ error: error.message });
}
});
Maintenant, crée une route PUT /api/users/:id pour mettre à jour un user.L'IA va générer exactement dans ton style : même structure try/catch, même format de réponse, même gestion d'erreurs.
#### Cas 2 : Components React avec tes conventions
Prompt Few-Shot :
Voilà comment je structure mes components React :
Exemple 1 :
interface ButtonProps {
label: string;
onClick: () => void;
variant?: 'primary' | 'secondary';
}
export const Button = ({ label, onClick, variant = 'primary' }: ButtonProps) => {
return (
<button
onClick={onClick}
className={`btn btn-${variant}`}
>
{label}
</button>
);
};
Exemple 2 :
interface InputProps {
value: string;
onChange: (value: string) => void;
placeholder?: string;
}
export const Input = ({ value, onChange, placeholder }: InputProps) => {
return (
<input
type="text"
value={value}
onChange={(e) => onChange(e.target.value)}
placeholder={placeholder}
className="input"
/>
);
};
Maintenant, crée un component Select avec options, value, onChange.#### Cas 3 : Migrations de base de données
Voilà mes migrations MongoDB :
Exemple 1 :
// Migration: add_email_verified_field
db.users.updateMany(
{ emailVerified: { $exists: false } },
{ $set: { emailVerified: false } }
);
Exemple 2 :
// Migration: add_created_at_index
db.users.createIndex({ createdAt: -1 });
Crée une migration pour ajouter un champ "lastLoginAt" (Date) à tous les users.Pourquoi ça marche mieux ?
Les exemples servent de conditionnement pour les réponses suivantes. L'IA apprend ton style, tes conventions, ta façon de structurer le code.
C'est particulièrement puissant pour :
- Respecter les conventions de ton équipe
- Générer du code cohérent avec ta codebase
- Maintenir un style uniforme
Pattern #3 : Chain-of-Thought (pour la logique complexe)
C'est quoi exactement ?
Chain-of-Thought prompting décompose les problèmes complexes en étapes de raisonnement intermédiaires. Tu demandes à l'IA de "penser à voix haute" avant de répondre.
C'est comme quand tu débugges : tu n'arrives pas directement à la solution, tu décomposes le problème étape par étape.
Deux versions : Zero-Shot CoT et Few-Shot CoT
#### Zero-Shot CoT : La magie du "Réfléchis étape par étape"
On dit simplement au modèle de montrer son raisonnement avec des instructions comme "Résolvons ceci étape par étape".
Prompt Zero-Shot CoT :
J'ai une API qui devient lente quand il y a beaucoup d'utilisateurs connectés.
La base de données MongoDB est sur le même serveur que l'API Node.js.
Les requêtes GET /users prennent 5 secondes avec 1000 users en DB.
Réfléchis étape par étape : quel est le problème et comment le résoudre ?Réponse attendue (avec raisonnement) :
Étape 1 : Analyser le problème
- 5 secondes pour 1000 users = problème de performance évident
- GET /users récupère probablement TOUS les users d'un coup
- Pas de pagination visible
Étape 2 : Identifier la cause racine
- Query non optimisée : `User.find()` sans limite
- Absence d'index sur les champs souvent requêtés
- Pas de cache pour les données peu changeantes
Étape 3 : Solutions recommandées
1. Implémenter la pagination (limit, skip)
2. Ajouter des index MongoDB sur les champs filtrés
3. Mettre en place un cache Redis pour les listes d'users
4. Utiliser `select()` pour ne récupérer que les champs nécessaires
Étape 4 : Code recommandé
// Avant
const users = await User.find();
// Après
const page = parseInt(req.query.page) || 1;
const limit = 20;
const users = await User.find()
.select('name email avatar')
.limit(limit)
.skip((page - 1) * limit)
.lean(); // Optimisation MongooseTu vois ? L'IA décompose le raisonnement au lieu de balancer une solution directement.
#### Few-Shot CoT : Montrer comment tu veux que l'IA raisonne
Prompt Few-Shot CoT :
Voilà comment je veux que tu analyses les bugs :
Exemple :
Bug : Mon composant React re-render en boucle infinie
Analyse :
1. Identifier le déclencheur : useEffect sans tableau de dépendances
2. Tracer le cycle : composant render → useEffect → setState → re-render
3. Solution : ajouter [] comme dépendances pour exécuter une seule fois
4. Code corrigé :
useEffect(() => {
fetchData();
}, []); // Dépendances vides
Maintenant analyse ce bug :
Mon API Next.js Server Action est appelée plusieurs fois alors que je clique une seule fois sur le bouton.Réponse attendue :
Analyse :
1. Identifier le déclencheur :
- Bouton probablement dans un formulaire
- Le form se submit + l'onClick se déclenche = double appel
2. Tracer le cycle :
- User clique → onClick déclenché
- Form submit automatique → action appelée une 2e fois
3. Solution :
- Soit utiliser event.preventDefault()
- Soit retirer le form et garder juste le bouton
- Soit utiliser formAction au lieu d'onClick
4. Code corrigé :
// Option 1 : preventDefault
<form onSubmit={(e) => { e.preventDefault(); handleAction(); }}>
<button type="submit">Submit</button>
</form>
// Option 2 : formAction (recommandé pour Server Actions)
<form action={serverAction}>
<button type="submit">Submit</button>
</form>Cas d'usage réels pour devs
1. Architecture de features complexes
Je veux implémenter un système de notifications temps réel dans mon app Next.js.
Réfléchis étape par étape :
- Quelle technologie utiliser (WebSockets, SSE, polling) ?
- Comment gérer la persistance des notifications ?
- Comment optimiser pour ne pas surcharger le serveur ?
Propose une architecture complète avec le raisonnement derrière chaque choix.2. Debugging de problèmes de performance
Mon app Next.js a un score Lighthouse de 45.
- LCP : 6.5s
- FCP : 3.2s
- Bundle size : 850kb
Analyse étape par étape :
1. Quels sont les problèmes principaux ?
2. Par quoi commencer en priorité ?
3. Solutions concrètes avec code3. Refactoring de code legacy
Voilà une fonction legacy que je veux refactorer :
function processUsers(users) {
var result = [];
for (var i = 0; i < users.length; i++) {
if (users[i].age > 18) {
var user = users[i];
user.isAdult = true;
result.push(user);
}
}
return result;
}
Réfléchis étape par étape :
1. Quels sont les problèmes de ce code ?
2. Comment le moderniser (ES6+, functional programming) ?
3. Comment le rendre plus performant ?
4. Propose le code refactoré avec explicationsCombiner les patterns : Le workflow ultime
Franchement, la vraie puissance vient quand tu combines ces patterns selon la situation.
Workflow recommandé
Tâche simple et standard
↓
Zero-Shot
↓
Ça marche ? → OUI → Terminé ✓
↓ NON
↓
Few-Shot (ajoute 1-2 exemples)
↓
Ça marche ? → OUI → Terminé ✓
↓ NON
↓
Chain-of-Thought (décompose le problème)
↓
Résolu ✓Exemple réel combiné
Contexte : Tu veux générer une feature complète d'authentification
Étape 1 : Zero-Shot pour le plan global
Liste les étapes pour implémenter l'authentification JWT dans une app Next.js avec MongoDB.Étape 2 : Few-Shot pour le code selon ton style
Voilà comment je structure mes API routes (exemples...)
Maintenant crée les routes :
- POST /api/auth/register
- POST /api/auth/login
- POST /api/auth/refreshÉtape 3 : Chain-of-Thought pour la sécurité
Réfléchis étape par étape : quelles mesures de sécurité ajouter pour protéger ces routes ?
- Validation des inputs
- Rate limiting
- Protection CSRF
- Gestion des tokens
- etc.
Propose une implémentation sécurisée complète.Patterns avancés : Pour aller plus loin
1. Role Prompting (définir le contexte)
Tu es un développeur senior Full-Stack spécialisé en Next.js et MongoDB,
avec 5 ans d'expérience en optimisation de performance.
Analyse mon code et propose des améliorations :
[ton code ici]2. Constraint Prompting (définir les limites)
Crée une fonction de recherche d'users AVEC ces contraintes :
- Compatible avec MongoDB
- Doit gérer la pagination
- Maximum 50 lignes de code
- Typage TypeScript strict
- Gestion d'erreurs complète3. Output Format Prompting (format précis)
Génère la documentation de cette API.
Format souhaité :
## Endpoint
- Method:
- URL:
- Auth required:
## Parameters
| Name | Type | Required | Description |
## Response// Type de réponse
## Examplecurl ...
Outils et ressources pour prompt engineering
Frameworks pour développeurs
Il existe des frameworks orientés développeurs comme LangChain et PromptFlow qui permettent de chaîner les prompts et de les intégrer dans les applications.
LangChain (Python/JS)
import { PromptTemplate } from "langchain/prompts";
const template = `
Voilà comment je structure mes {component_type} :
{examples}
Maintenant crée un {component_type} pour {description}.
`;
const prompt = new PromptTemplate({
template: template,
inputVariables: ["component_type", "examples", "description"],
});Prompt Templates dans ton IDE
Crée des snippets réutilisables :
// .vscode/prompts.json
{
"api-route-generator": {
"prefix": "!api",
"body": [
"Voilà comment je structure mes API routes Express:",
"",
"Exemple 1:",
"${1:exemple}",
"",
"Maintenant crée une route ${2:METHOD} ${3:path} pour ${4:description}."
]
}
}Tester et itérer
1. Garde un "prompt log" : note ce qui marche et ce qui ne marche pas
2. Compare les modèles : ChatGPT vs Claude vs Copilot pour différents cas
3. Mesure le temps : combien de reformulations avant d'avoir le bon résultat ?
Checklist : Es-tu efficace avec tes prompts ?
Avant de promter, pose-toi ces questions :
Clarté
- [ ] Mon prompt est-il spécifique et sans ambiguïté ?
- [ ] Ai-je défini le format de sortie souhaité ?
- [ ] Ai-je précisé les contraintes (langage, framework, style) ?
Contexte
- [ ] L'IA a-t-elle assez d'informations ?
- [ ] Ai-je donné des exemples si nécessaire ?
- [ ] Le contexte est-il pertinent pour la tâche ?
Complexité
- [ ] La tâche est-elle simple → Zero-Shot suffit ?
- [ ] Besoin d'un style spécifique → Few-Shot ?
- [ ] Problème complexe → Chain-of-Thought ?
Vérification
- [ ] Le code généré compile-t-il ?
- [ ] Est-il conforme à mes conventions ?
- [ ] Ai-je compris ce que l'IA a généré ?
Conclusion : Prompt Engineering = Compétence de dev en 2026
Regarde, le prompt engineering utilise des techniques comme few-shot, zero-shot et chain-of-thought pour améliorer la résolution de problèmes et l'adaptabilité. Ce n'est pas de la magie, c'est une compétence technique.
Les développeurs qui maîtrisent le prompt engineering :
- Sont 3-5x plus productifs avec les outils IA
- Génèrent du code de meilleure qualité du premier coup
- Perdent moins de temps à reformuler leurs demandes
- Comprennent mieux ce que l'IA peut et ne peut pas faire
Ton plan d'action immédiat :
1. Aujourd'hui : Teste Zero-Shot sur 5 tâches simples
2. Cette semaine : Crée 3 prompts Few-Shot pour ton workflow
3. Ce mois-ci : Utilise Chain-of-Thought pour un problème complexe
4. Long terme : Build ta bibliothèque de prompts réutilisables
Le prompt engineering n'est pas réservé aux "prompt engineers". C'est une compétence de développeur, au même titre que savoir utiliser Git ou écrire des tests.
La différence ? Ceux qui la maîtrisent construisent plus vite, mieux, et avec moins de frustration.
Et toi : quel pattern vas-tu tester en premier ?
Partage ton expérience en commentaire, et dis-moi quel prompt t'a fait gagner le plus de temps cette semaine ! 👇
Retrouve-moi sur GitHub pour d'autres ressources et discussions tech. Si l'article t'a aidé, partage-le avec tes collègues devs.
Ressources pour aller plus loin
- Prompt Engineering Guide - Guide complet et à jour
- OpenAI Prompt Engineering Guide - Documentation officielle
- Anthropic Prompt Library - Prompts pour Claude
- LangChain Documentation - Pour automatiser tes prompts
Mots-clés : prompt engineering, ChatGPT développeurs, Claude prompts, GitHub Copilot, Chain of Thought, Few-Shot prompting, Zero-Shot, prompt patterns, AI pour développeurs, prompt engineering tutorial, LangChain, développeur Full-Stack
