Ingénierie de prompts IA : commandes et techniques essentielles pour les développeurs

L'ingénierie de prompts est devenue l'une des compétences les plus critiques pour les développeurs utilisant des outils IA. Que vous utilisiez ChatGPT, Claude, GitHub Copilot ou Cursor, la qualité du prompt détermine directement la qualité de la sortie de l'IA. Un prompt bien conçu peut transformer une réponse vague et inutile en un code précis et prêt pour la production. Ce guide complet couvre tout, des techniques de prompting de base aux stratégies avancées, en passant par les conseils spécifiques à chaque outil et les modèles prêts à l'emploi, pour vous aider à tirer le maximum de valeur de chaque interaction avec l'IA.

Qu'est-ce que l'ingénierie de prompts ?

L'ingénierie de prompts est l'art et la science de concevoir des instructions efficaces pour les modèles de langage IA afin de produire les résultats souhaités. En son cœur, il s'agit de communication — apprendre à exprimer vos intentions dans le langage que les modèles IA comprennent le mieux. Tout comme un développeur senior donnerait des instructions plus précises à un développeur junior pour obtenir de meilleurs résultats, l'ingénierie de prompts vous apprend à communiquer vos intentions de manière claire et précise aux systèmes IA.

Pour les développeurs, l'ingénierie de prompts est importante car les assistants de programmation IA sont devenus une partie indispensable du flux de travail de développement moderne. Ces outils peuvent générer du code, déboguer des problèmes, rédiger des tests, refactoriser des architectures et expliquer des systèmes complexes — mais seulement si vous donnez les bonnes instructions. Un prompt mal rédigé peut produire du code qui compile mais ne correspond pas à vos intentions, qui utilise la mauvaise version d'un framework ou qui ignore des cas limites cruciaux. En revanche, un prompt bien conçu peut produire une sortie indiscernable de celle d'un développeur expérimenté.

De petites variations dans le prompt peuvent avoir un impact énorme. Comparez la différence entre « corrige le bug » et « corrige l'exception de référence nulle dans la méthode UserService.authenticate lorsque le paramètre email est undefined. La méthode se trouve dans src/services/UserService.ts et utilise bcrypt pour la comparaison de mots de passe ». Le premier prompt ne fournit pratiquement aucune information utile à l'IA. Le second fournit une description claire du problème, son emplacement et son contexte — permettant à l'IA de produire une correction précise et correcte dès la première tentative.

Techniques de base de prompting

Comprendre les techniques de prompting fondamentales vous donne une base solide. Chaque technique a ses cas d'utilisation spécifiques, et les ingénieurs en prompts expérimentés combinent souvent plusieurs techniques dans un seul prompt pour un effet optimal.

Prompting zéro-shot

Le prompting zéro-shot est la forme la plus simple de prompting — vous donnez directement une instruction à l'IA sans fournir aucun exemple. L'IA s'appuie entièrement sur ses données d'entraînement et les informations contenues dans le prompt pour générer sa réponse. Cette technique fonctionne bien pour les tâches simples où le format de sortie souhaité est évident, ou lorsque l'IA a vu de nombreux exemples similaires pendant son entraînement.

Write a Python function that validates an email address using regex.
The function should return True for valid emails and False for invalid ones.

Le prompting zéro-shot est efficace pour les tâches courantes et bien définies. Cependant, lorsque vous avez besoin d'un format de sortie spécifique, d'un style particulier ou d'une approche précise, le prompting few-shot est plus fiable.

Prompting few-shot

Le prompting few-shot consiste à fournir un ou plusieurs exemples du pattern entrée-sortie souhaité avant de donner la tâche réelle. Cette technique est très puissante car elle montre exactement ce que vous voulez, réduisant l'ambiguïté et guidant l'IA vers le bon format et le bon style. L'IA apprend le pattern à partir de vos exemples et l'applique aux nouvelles entrées.

Convert these database column names to camelCase JavaScript variable names:

user_first_name -> userFirstName
created_at_timestamp -> createdAtTimestamp
is_email_verified -> isEmailVerified
total_order_count ->

Now convert: product_category_id

Le prompting few-shot est particulièrement précieux lorsque vous avez besoin d'un format cohérent, de conventions de codage spécifiques, ou lorsque l'IA pourrait faire des hypothèses qui ne correspondent pas au style de votre projet. En général, deux ou trois exemples suffisent pour établir un pattern clair.

Prompting chaîne de pensée

Le prompting chaîne de pensée demande à l'IA de raisonner étape par étape sur un problème avant de donner sa réponse finale. Cette technique améliore considérablement la précision sur les tâches complexes car elle force l'IA à traiter les étapes intermédiaires plutôt que de sauter à une conclusion potentiellement incorrecte. Des études montrent que l'ajout de « think step by step » dans le prompt peut améliorer la précision de 30 à 50 % sur les tâches de raisonnement.

Analyze this React component for performance issues. Think step by step:

1. First, identify all state variables and their update patterns
2. Then, check for unnecessary re-renders
3. Next, look for missing memoization opportunities
4. Finally, suggest specific optimizations with code examples

Here's the component:
[component code]

Le prompting chaîne de pensée est indispensable pour le débogage, les décisions d'architecture et toute tâche nécessitant un raisonnement logique. En demandant à l'IA de montrer son processus de raisonnement, vous obtenez également la capacité de vérifier son raisonnement et de repérer les erreurs dans les étapes intermédiaires.

Prompting par jeu de rôle

Le prompting par jeu de rôle attribue à l'IA un rôle ou un niveau d'expertise spécifique, ce qui influence la profondeur, le style et le focus de ses réponses. Lorsque vous dites à l'IA « joue le rôle d'un ingénieur DevOps senior », elle adopte une perspective différente, fournissant des conseils plus orientés vers la production et les opérations plutôt que des snippets de code génériques. Cette technique exploite l'entraînement de l'IA sur du contenu spécifique à un domaine pour produire des réponses de niveau expert.

Act as a senior security engineer with 15 years of experience in web application security. Review this authentication implementation and identify any vulnerabilities, ranking them by severity. For each vulnerability, explain the attack vector and provide a secure code fix.

La clé d'un jeu de rôle efficace réside dans la spécificité. « Joue le rôle d'un développeur Python » est trop vague. « Joue le rôle d'un développeur Python spécialisé dans la construction de pipelines de données haute performance avec Apache Airflow et pandas » donne à l'IA un cadre de référence beaucoup plus clair.

Prompts système vs prompts utilisateur

La plupart des outils IA distinguent les prompts système et les prompts utilisateur. Les prompts système définissent des instructions persistantes qui s'appliquent à l'ensemble de la conversation, tandis que les prompts utilisateur sont des messages individuels. Comprendre cette distinction est crucial pour maintenir la cohérence lors d'interactions prolongées.

CLAUDE.md sert de prompt système persistant. Dans ChatGPT, vous pouvez définir des instructions personnalisées comme prompt système pour toutes les conversations.

# System prompt example
You are a TypeScript expert working on a Next.js 14 project using:
- App Router (not Pages Router)
- Server Components by default
- Prisma for database access
- Tailwind CSS for styling
- Zod for validation

Always use strict TypeScript. Prefer server actions over API routes.
Never use 'any' type. Use 'unknown' and narrow with type guards.

# User prompt example
Add a user profile page that shows the current user's name, email,
avatar, and last 10 activity records. Include loading states and
error handling.

Commandes IA essentielles pour les développeurs

Certains patterns de commandes se sont révélés très efficaces sur tous les principaux outils de programmation IA. Ce ne sont pas des commandes littérales, mais des phrases d'instruction qui déclenchent systématiquement des réponses de haute qualité. Considérez-les comme des mots de pouvoir qui activent des capacités spécifiques du modèle IA.

"Act as..." / "You are a..." — attribution de rôle

L'attribution de rôle est l'une des commandes les plus puissantes de l'ingénierie de prompts. En spécifiant un rôle, vous activez les connaissances spécifiques à un domaine et fixez des attentes quant à la profondeur et au style de la réponse. Plus le rôle est spécifique, meilleure est la sortie.

You are a senior backend engineer at a fintech company who specializes
in building secure, high-throughput payment processing systems.
You have deep expertise in PostgreSQL, Redis, and distributed systems.
You always consider edge cases, race conditions, and failure modes.

Design a payment processing API that handles:
- Credit card payments via Stripe
- Bank transfers via Plaid
- Retry logic with exponential backoff
- Idempotency keys to prevent duplicate charges

"Step by step" — chaîne de pensée

Ajouter « step by step » ou « let's think step by step » dans le prompt déclenche la décomposition du raisonnement de l'IA. C'est particulièrement efficace pour le débogage, la conception d'algorithmes et les décisions d'architecture. L'approche étape par étape produit non seulement de meilleurs résultats, mais rend également le raisonnement de l'IA transparent, vous permettant de repérer les erreurs logiques.

Debug this SQL query that's causing a timeout. Think step by step:

1. First, analyze the query structure and joins
2. Identify potential performance bottlenecks
3. Check for missing indexes
4. Suggest an optimized version with EXPLAIN analysis

SELECT u.name, COUNT(o.id), SUM(o.amount)
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.created_at > '2026-01-01'
GROUP BY u.name
HAVING COUNT(o.id) > 10
ORDER BY SUM(o.amount) DESC;

"Think aloud" — transparence du raisonnement

« Think aloud » est similaire à « step by step » mais se concentre davantage sur le processus de décision de l'IA. Il demande à l'IA de narrer son raisonnement, y compris les alternatives envisagées et pourquoi une approche particulière a été choisie. C'est très précieux lorsque vous devez comprendre les compromis dans une décision de conception ou évaluer si le raisonnement de l'IA est solide.

I need to choose between WebSocket and Server-Sent Events for a
real-time notification system. Think aloud about the trade-offs,
considering: browser support, bidirectional communication needs,
server resource usage, and scalability. Then recommend one with
justification.

"Explain like I'm 5" — explication simplifiée

Lors de l'apprentissage de nouveaux concepts ou de la tentative de comprendre du code complexe, « explain like I'm 5 » (ELI5) élimine le jargon et fournit des explications intuitives basées sur des analogies. C'est particulièrement utile pour l'intégration à un nouveau projet, la compréhension d'une codebase inconnue ou l'explication de concepts techniques à des parties prenantes non techniques.

Explain like I'm 5: What is a monad in functional programming,
and why do Haskell developers keep talking about them?
Use a real-world analogy, not code.

"Review and critique" — revue de code

Utiliser « review and critique » signale à l'IA d'adopter une perspective critique plutôt que d'accepter simplement le code. Cela produit une analyse plus approfondie, y compris les bugs potentiels, les problèmes de sécurité, les problèmes de performance et les violations de style. C'est comme avoir une revue de code par un ingénieur senior à la demande.

Review and critique this Express.js middleware. Focus on:
- Security vulnerabilities
- Error handling gaps
- Performance concerns
- Best practice violations
- Suggest improvements with code examples

[paste your middleware code]

"Write tests for" — génération de tests

La génération de tests est l'une des utilisations à plus forte valeur des outils de programmation IA. En spécifiant « write tests for » avec votre framework de test et vos attentes de couverture, vous pouvez rapidement générer des suites de tests complètes. La clé est de spécifier les cas limites et les priorités de test.

Write tests for the UserService.register method using Jest.
Cover these scenarios:
- Happy path with valid input
- Duplicate email registration
- Invalid email format
- Password too short
- Missing required fields
- Database connection failure
- Concurrent registration attempts

Use describe/it blocks. Include setup and teardown.
Mock the database layer.

"Refactor using..." — refactorisation basée sur des patterns

Spécifier un design pattern ou un principe dans le prompt de refactorisation donne à l'IA une architecture cible explicite. Plutôt qu'une demande vague de « refactorise ceci », nommer le pattern produit une refactorisation concentrée et cohérente qui suit les principes de génie logiciel établis.

Refactor this notification system using the Strategy pattern.
Currently, all notification types (email, SMS, push) are handled
in a single class with if-else chains. Create separate strategy
classes for each notification type, a context class that delegates
to the active strategy, and a factory for creating strategies.

[paste your current code]

"Find bugs in" — débogage

La commande « Find bugs in » active le mode analytique de l'IA, l'incitant à chercher des problèmes plutôt qu'à générer du code. Elle fonctionne mieux lorsque vous fournissez le code, décrivez le comportement attendu et mentionnez les symptômes observés.

Find bugs in this async Node.js function. It's supposed to process
a batch of orders and update their status, but sometimes orders
get processed twice and the status updates are inconsistent under
high load.

[paste your function code]

"Add error handling" — renforcement de la robustesse

De nombreux snippets de code générés par l'IA fonctionnent sur le chemin normal mais manquent de gestion appropriée des erreurs. La commande « Add error handling » cible spécifiquement cette lacune, demandant à l'IA de considérer les modes de panne, les cas limites et les stratégies de récupération.

Add error handling to this file upload function. Consider:
- File size limits
- Invalid file types
- Network interruptions during upload
- Disk space errors
- Concurrent upload conflicts
- Partial upload cleanup

Use try-catch with specific error types. Add retry logic for
transient failures. Return meaningful error messages to the client.

Patterns de prompting pour la génération de code

Au-delà des commandes individuelles, certains patterns de prompting se sont révélés particulièrement efficaces pour des types spécifiques de tâches de génération de code. Ces patterns combinent des techniques comme l'attribution de rôle, la fourniture de contexte et la spécification de sortie en prompts structurés qui produisent systématiquement des résultats de haute qualité.

Prompt d'implémentation de fonctionnalité

Lors de l'implémentation d'une nouvelle fonctionnalité, le prompt le plus efficace suit une structure semblable à une spécification : décrivez la fonctionnalité, spécifiez la stack technique, définissez les critères d'acceptation et mentionnez toute contrainte. Cela donne à l'IA une image complète de ce qu'il faut construire.

Implement a user avatar upload feature for a Next.js 14 application.

Tech stack: Next.js App Router, TypeScript, Prisma, PostgreSQL, AWS S3

Requirements:
- Accept JPEG, PNG, WebP (max 5MB)
- Resize to 200x200 and 400x400 thumbnails using Sharp
- Upload originals to S3 with unique keys
- Store S3 URLs in the User model
- Delete old avatar when uploading a new one
- Return presigned URLs for frontend display

Acceptance criteria:
- Invalid file types return 400 with error message
- Files over 5MB return 413
- Successful upload returns 200 with avatar URLs
- Old avatars are cleaned up from S3

Create: API route, service layer, Prisma schema update, and types.

Prompt de conception d'API

Les prompts de conception d'API bénéficient de la spécification préalable du style d'architecture, de la méthode d'authentification, de la stratégie de versionnage et du format de réponse. Cela garantit que l'API générée est cohérente et suit les conventions de votre projet.

Design a RESTful API for a project management application.

Architecture: Express.js with TypeScript, following clean architecture
Auth: JWT with refresh token rotation
Versioning: URL-based (/api/v1/)
Response format: { success: boolean, data?: T, error?: { code, message } }

Endpoints needed:
- Projects CRUD with team membership
- Tasks CRUD with assignee, priority, status
- Comments on tasks with mentions
- Activity feed (recent actions across projects)

Include:
- Request/response TypeScript interfaces
- Zod validation schemas
- Error handling middleware
- Pagination for list endpoints (cursor-based)

Prompt de schéma de base de données

Les prompts de schéma de base de données devraient spécifier l'ORM, les conventions de nommage, la stratégie d'indexation et les relations. L'IA peut générer un schéma complet avec les contraintes, les index et les fichiers de migration appropriés.

Design a Prisma schema for an e-commerce platform with these entities:

- Users (authentication, profile, addresses)
- Products (variants, categories, inventory)
- Orders (line items, status history, payments)
- Reviews (ratings, images, helpful votes)
- Cart (items, applied coupons)

Requirements:
- Use PostgreSQL with UUID primary keys
- Soft deletes with deletedAt timestamps
- Proper indexes for common query patterns
- Enums for order status, payment status
- Decimal fields for prices (not float)
- Full-text search on product name and description
- Include a migration file

Prompt de composant UI

Pour les composants UI, spécifier le framework, l'approche de style, les exigences d'accessibilité et les états interactifs produit de meilleurs résultats qu'un prompt générique de « crée un composant ».

Create a reusable DataTable component in React with TypeScript.

Styling: Tailwind CSS + shadcn/ui conventions
Features:
- Column definitions with sort, filter, and custom renderers
- Server-side pagination with page size selector
- Row selection (single and multi) with checkboxes
- Loading skeleton state
- Empty state with custom message
- Responsive: card layout on mobile, table on desktop

Accessibility:
- Keyboard navigation (arrow keys, Enter, Escape)
- Screen reader announcements for sort and filter changes
- ARIA labels on all interactive elements

Props interface:
- data, columns, isLoading, pagination, onSort, onFilter, onSelect

Include a usage example with a user list table.

Prompt de configuration et DevOps

Les prompts DevOps et de configuration devraient spécifier l'environnement cible, les exigences de sécurité et toute norme organisationnelle. Cela empêche l'IA de générer des configurations génériques qui ne correspondent pas à votre infrastructure.

Create a Docker Compose setup for a development environment with:
- Next.js app (hot reload enabled)
- PostgreSQL 16 with persistent volume
- Redis for session storage
- MinIO (S3-compatible) for local file storage

Requirements:
- All services on a shared network
- Environment variables from .env file
- Health checks for all services
- Volumes for node_modules (avoid bind mount issues)
- PostgreSQL initialized with seed data
- Non-root containers where possible

Also create:
- Dockerfile for the Next.js app (multi-stage build)
- .env.example with all required variables
- Makefile with common commands (up, down, logs, reset-db)

Stratégies de prompting avancées

Une fois que vous maîtrisez les techniques de base et les commandes, ces stratégies avancées vous aideront à gérer des tâches de développement complexes et en plusieurs étapes qui dépassent les capacités d'un seul prompt.

Chaînage de prompts

Le chaînage de prompts décompose une tâche complexe en une série de prompts plus petits et plus ciblés, chacun s'appuyant sur la sortie du précédent. Cette stratégie produit de meilleurs résultats que d'essayer de tout faire dans un seul prompt massif, car chaque étape reçoit l'attention et le contexte complets de l'IA.

# Step 1: Design the architecture
"Design the architecture for a real-time chat application.
List the components, their responsibilities, and how they
communicate. Use a diagram-like text format."

# Step 2: Define the data model
"Based on the architecture above, design the database schema
for the chat application. Include users, conversations,
messages, and read receipts. Use Prisma schema format."

# Step 3: Implement the API
"Implement the REST API for the chat application based on
the architecture and schema we designed. Start with the
message endpoints: send, list, delete."

# Step 4: Add WebSocket support
"Now add WebSocket support for real-time message delivery.
Use Socket.io. Integrate with the existing message API."

# Step 5: Write tests
"Write integration tests for the chat API and WebSocket
events using Jest and Supertest."

La clé d'un chaînage de prompts efficace est de s'assurer que chaque étape produit une sortie complète et utilisable avant de passer à la suivante. Examinez chaque sortie, corrigez si nécessaire, puis alimentez le résultat affiné dans le prompt suivant.

Remplissage de contexte

Le remplissage de contexte consiste à fournir à l'IA tout le code, la documentation et le contexte pertinents avant de poser votre question. Bien que cela puisse sembler évident, de nombreux développeurs sautent cette étape puis s'étonnent que l'IA fasse des hypothèses incorrectes. Plus vous fournissez de contexte pertinent, plus la réponse de l'IA sera précise et spécifique.

 {
    await this.db.query('UPDATE users SET email = $1 WHERE id = $2', [email, id]);
    await this.cache.del(`user:${id}`);
  }
}
```

Here is the User type:
```typescript
interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
  createdAt: Date;
}
```

Now, add an updateProfile method that allows updating name and email,
with validation that the email is not already taken by another user.

Notez comment la fourniture du code existant et des types permet à l'IA de générer une méthode parfaitement cohérente avec les patterns existants, utilisant la même stratégie de cache et suivant les définitions de types existantes.

Spécification de contraintes

Définir des contraintes explicites empêche l'IA de faire des hypothèses indésirables. Les contraintes définissent ce que l'IA ne doit pas faire, ce qui est souvent aussi important que ce qu'elle devrait faire. Les contraintes courantes incluent les versions techniques, les exigences de performance, les règles de sécurité et les normes de codage.

Build a URL shortener API with these constraints:

MUST:
- Use Node.js 20+ with native fetch (no axios)
- Use PostgreSQL via pg driver (no ORM)
- Generate short codes of exactly 7 characters
- Support custom aliases (max 20 chars)
- Return 301 for existing short URLs
- Rate limit to 100 creates per hour per IP

MUST NOT:
- Use any ORM or query builder
- Store full URLs without normalization
- Allow short codes that conflict with existing routes
- Return database errors to the client

PERFORMANCE:
- Handle 10,000 requests per second
- Cache hot URLs in Redis with 5-minute TTL
- P99 latency under 50ms for redirects

Contrôle du format de sortie

Spécifier le format de sortie souhaité garantit que la réponse de l'IA est immédiatement utilisable sans reformatage. C'est particulièrement important lorsque la sortie doit être analysée par d'autres outils, insérée dans de la documentation ou utilisée comme fichier de configuration.

Analyze this codebase and provide the output in this exact format:

## Architecture Overview
[2-3 paragraph summary]

## Component Diagram
```mermaid
graph TD
    [components and relationships]
```

## API Endpoints
| Method | Path | Description | Auth |
|--------|------|-------------|------|

## Database Tables
| Table | Columns | Indexes | Relations |
|-------|---------|---------|-----------|

## Recommendations
1. [Priority] [Description] - [Estimated effort]
2. ...

## Technical Debt
- [ ] [Description] - [Impact: High/Medium/Low]

Affinage itératif

L'affinage itératif est la pratique d'améliorer progressivement la sortie de l'IA via des prompts de suivi. La première réponse est rarement parfaite, mais elle fournit un point de départ qui peut être affiné. Chaque itératif approche plus efficacement le résultat souhaité que d'essayer d'être parfait dans un seul prompt.

# Iteration 1: Get a starting point
"Write a rate limiter middleware for Express.js"

# Iteration 2: Add specificity
"Good start. Now modify it to use Redis for distributed
rate limiting across multiple server instances. Use sliding
window instead of fixed window."

# Iteration 3: Add edge cases
"Add handling for: Redis connection failures (fall back to
in-memory), custom rate limits per route, burst allowance
for legitimate traffic spikes, and proper headers
(X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset)."

# Iteration 4: Add tests
"Write comprehensive tests for all the scenarios we've
covered, including Redis failures and burst handling."

Cette approche itérative est plus efficace que de rédiger un seul prompt massif car chaque itération vous permet de corriger et d'ajouter des détails en fonction de la sortie précédente de l'IA. Elle reflète la façon dont vous collaborez avec un développeur humain : commencer par une implémentation approximative, puis affiner.

Conseils de prompting spécifiques à chaque outil

Bien que les techniques ci-dessus s'appliquent à tous les outils IA, chaque plateforme a ses propres forces et caractéristiques. Adapter votre style de prompting aux spécificités de chaque outil peut améliorer considérablement les résultats.

ChatGPT / GPT-4

ChatGPT et GPT-4 excellent dans les interactions conversationnelles et bénéficient de prompts structurés et bien organisés. Ils gèrent bien les longs contextes et sont particulièrement doués pour expliquer des concepts et générer de la documentation.

• Utilisez les instructions personnalisées : définissez votre stack technique et vos préférences dans les instructions personnalisées de ChatGPT pour ne pas avoir à les répéter à chaque conversation.
• Exploitez Code Interpreter : pour les tâches d'analyse de données, demandez à ChatGPT d'utiliser Code Interpreter pour exécuter du code Python et générer des visualisations.
• Utilisez le formatage markdown dans les prompts : GPT-4 répond bien aux prompts structurés avec des titres, des puces et des blocs de code.
• Spécifiez la longueur de réponse : GPT-4 a tendance à être verbeux. Lorsque vous avez besoin de concision, ajoutez « sois concis » ou « en moins de 200 mots ».
• Utilisez les messages système : dans l'API, utilisez les messages système pour définir des instructions persistantes comme les normes de codage et le contexte du projet.

# Effective GPT-4 prompt structure
**Role:** Senior TypeScript developer
**Task:** Implement a JWT authentication middleware
**Context:** Express.js API, PostgreSQL, existing User model
**Constraints:** No external auth libraries, use crypto module
**Output:** Complete, production-ready code with types
**Format:** Single file with inline comments for complex logic

Claude / Claude Code

Claude et Claude Code sont particulièrement forts pour comprendre les grandes codebases, suivre des instructions complexes et produire des sorties bien structurées. Les capacités agentiques de Claude Code le rendent idéal pour les tâches en plusieurs étapes.

• Utilisez CLAUDE.md : c'est la chose la plus impactante que vous puissiez faire. Placez le contexte, les conventions et les préférences de votre projet dans CLAUDE.md.
• Spécifiez explicitement les emplacements de fichiers : Claude Code fonctionne mieux lorsque vous spécifiez les fichiers à lire et modifier.
• Laissez-le exécuter des commandes : Claude Code peut exécuter des tests et des commandes de build. Demandez-lui de vérifier son travail en exécutant des tests.
• Utilisez /compact dans les longues sessions : lorsque le contexte devient long, utilisez /compact pour compresser la conversation tout en conservant les informations les plus importantes.
• Exploitez les balises XML : Claude répond bien aux sections de prompts délimitées par des balises XML, permettant de séparer clairement les différentes parties de la requête.

# Effective Claude Code prompt
Read the following files to understand the current architecture:
- src/routes/userRoutes.ts
- src/middleware/authMiddleware.ts
- src/models/User.ts

Then refactor the authentication flow to support:
1. JWT access tokens (15 min expiry) + refresh tokens (7 day expiry)
2. Token rotation on refresh (invalidate old refresh token)
3. Rate limiting on the refresh endpoint (5 per minute per user)

Update all related files and run the test suite when done.

GitHub Copilot

GitHub Copilot fonctionne différemment des outils basés sur le chat — il fournit des suggestions en ligne pendant que vous tapez. Une utilisation efficace de Copilot repose sur l'écriture de code qui communique clairement l'intention via des commentaires, des signatures de types et le contexte environnant.

• Rédigez des commentaires descriptifs : ajoutez des commentaires comme // Validate email format and check for duplicates devant les fonctions pour donner à Copilot une intention claire.
• Utilisez les types TypeScript : des types et interfaces bien définis guident Copilot vers la bonne implémentation.
• Fournissez des exemples dans les commentaires : montrez l'entrée/sortie attendue dans les commentaires pour aider Copilot à correspondre au format souhaité.
• Acceptez les suggestions partielles : parfois Copilot a la bonne structure mais des détails incorrects. Acceptez la suggestion puis éditez les détails.
• Utilisez Copilot Chat pour les tâches complexes : pour les modifications multi-fichiers ou les décisions d'architecture, utilisez Copilot Chat plutôt que les suggestions en ligne.

> {
  // Copilot will generate the implementation based on these types

Cursor

Cursor combine l'intégration IDE avec des fonctionnalités de chat IA, offrant à la fois la complétion en ligne et une interface de chat consciente de votre codebase. Ses forces résident dans la perception profonde du projet et la capacité de référencer des fichiers et symboles spécifiques.

• Utilisez les références @file : référencez des fichiers spécifiques avec @filename pour donner à Cursor un contexte précis.
• Utilisez @codebase pour un contexte étendu : lorsque vous avez besoin que Cursor recherche dans tout le projet, utilisez @codebase.
• Utilisez @docs pour la documentation des bibliothèques : Cursor peut référencer la documentation de bibliothèques tierces avec @docs.
• Exploitez Cmd+K pour l'édition en ligne : sélectionnez du code et utilisez Cmd+K pour décrire les modifications en langage naturel.
• Définissez des règles de projet : utilisez le fichier .cursorrules (similaire à CLAUDE.md) pour définir des instructions de projet persistantes.

# Effective Cursor prompt
@src/services/paymentService.ts @src/types/payment.ts

Refactor the processPayment function to use the Strategy pattern.
Create separate strategy classes for each payment provider
(Stripe, PayPal, BankTransfer). The function should accept a
payment method and delegate to the appropriate strategy.

Keep the same public API so existing callers don't break.

Codex CLI

Codex CLI est l'agent de programmation basé sur le terminal d'OpenAI, conceptuellement similaire à Claude Code. Il excelle dans l'exécution de tâches de développement en plusieurs étapes depuis la ligne de commande.

• Fournissez un objectif clair : Codex CLI fonctionne mieux avec un objectif de haut niveau clair plutôt que des instructions étape par étape.
• Spécifiez le répertoire de travail : assurez-vous d'exécuter Codex CLI depuis le bon répertoire racine du projet.
• Utilisez d'abord le mode proposition : avant de laisser Codex effectuer des modifications, utilisez le mode proposition pour examiner son plan.
• Configurez les permissions du bac à sable avec prudence : contrôlez ce que Codex peut exécuter en configurant les permissions du bac à sable.
• Itérez sur la sortie : comme avec les autres outils, la première tentative peut nécessiter un affinage via des prompts de suivi.

Erreurs courantes et comment les éviter

Même les développeurs expérimentés commettent ces erreurs courantes de prompting. Les reconnaître et les éviter améliorera immédiatement vos interactions avec l'IA.

Invites vagues

L'erreur la plus courante est de fournir des instructions vagues et non spécifiques. Des prompts comme « corrige ceci », « améliore ceci » ou « ajoute une fonctionnalité » ne donnent pratiquement aucune information utile à l'IA. L'IA fait des hypothèses, et ces hypothèses ne correspondent souvent pas à vos intentions.

# Bad
"Fix the login bug"

# Good
"Fix the bug where users with uppercase emails cannot log in.
The issue is in src/auth/login.ts - the email comparison is
case-sensitive but emails are stored in lowercase in the database.
The fix should normalize the email to lowercase before comparison."

Contexte manquant

Les modèles IA ne connaissent pas votre projet à moins que vous ne le leur disiez. Ne pas fournir le contexte pertinent — votre stack technique, les versions de frameworks, les patterns de code existants ou la structure du projet — force l'IA à deviner, et elle se trompe souvent. Incluez toujours le contexte qu'un nouveau membre de l'équipe aurait besoin pour comprendre votre demande.

# Bad
"Write a function to send emails"

# Good
"Write an email sending function for our NestJS application.
We use:
- @nestjs/mailer with Handlebars templates
- SMTP via AWS SES
- Templates stored in src/templates/emails/
- Existing MailService class in src/mail/mail.service.ts

The function should accept a template name, recipient, and
template variables. Include error handling for SES throttling
and bounce notifications."

Surcharge de prompts

Essayer d'accomplir trop de tâches non liées dans un seul prompt produit des résultats médiocres dans tous les domaines. L'attention de l'IA est dispersée et elle peut sauter des détails importants pour certaines tâches tout en se concentrant excessivement sur d'autres. Décomposez les requêtes complexes en prompts ciblés et séquentiels.

# Bad - Too many tasks in one prompt
"Build a complete user management system with authentication,
profile management, email verification, password reset,
role-based access control, and an admin dashboard"

# Good - Break it into focused prompts
Prompt 1: "Design the database schema for a user management system..."
Prompt 2: "Implement the authentication endpoints..."
Prompt 3: "Add email verification flow..."
Prompt 4: "Implement role-based access control middleware..."

Ignorer le format de sortie

Lorsque vous avez besoin d'un format de sortie spécifique — JSON, markdown, une structure de fichiers spécifique — ne pas le spécifier entraîne un format imprévisible. L'IA peut retourner du texte narratif quand vous avez besoin de JSON, ou un seul fichier quand vous avez besoin de plusieurs fichiers. Spécifiez toujours explicitement le format de sortie souhaité.

# Bad
"List all the API endpoints"

# Good
"List all API endpoints in a markdown table with these columns:
| Method | Path | Description | Auth Required | Request Body | Response |"

Ne pas itérer

Accepter la première réponse de l'IA sans l'affiner est une opportunité manquée. La première réponse fournit une base que vous pouvez améliorer via des prompts de suivi. L'itération est là où réside la véritable puissance du développement assisté par l'IA — chaque cycle produit une sortie meilleure et plus affinée.

# Instead of accepting the first response, iterate:
"Good start. Now add input validation using Zod schemas."
"Now add proper error handling with custom error classes."
"Now add logging for all operations."
"Now write tests for all the edge cases we've discussed."

Bibliothèque de modèles de prompts

Voici des modèles de prompts prêts à l'emploi pour des tâches de développement courantes. Copiez ces modèles, remplissez les espaces réservés et adaptez-les à vos besoins spécifiques. Chaque modèle combine plusieurs techniques de prompting pour un effet maximal.

Modèle 1 : implémentation de fonctionnalité

You are a senior {language} developer specializing in {framework}.

Implement {feature_description} for our {project_type} application.

Tech stack:
- {language} {version} with {framework} {version}
- {database} for data storage
- {orm} for database access
- {testing_framework} for tests

Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Constraints:
- Must follow existing patterns in the codebase
- Must include input validation
- Must handle errors gracefully
- Must be backward compatible

Output:
1. Implementation code with inline comments for complex logic
2. Unit tests covering happy path and edge cases
3. Brief explanation of design decisions

Modèle 2 : investigation de bug

You are a debugging specialist with expertise in {language}/{framework}.

Investigate and fix this bug:

**Symptom:** {describe_the_observed_behavior}
**Expected:** {describe_the_expected_behavior}
**Frequency:** {always/sometimes/under_specific_conditions}
**Environment:** {production/staging/development}

Relevant code:
```
{paste_relevant_code}
```

Error output / stack trace:
```
{paste_error_output}
```

Think step by step:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide the fix with code
4. Suggest how to prevent similar bugs
5. Write a regression test

Modèle 3 : revue de code

You are a senior code reviewer at a {company_type} company.

Review this {language} code for:

1. **Correctness:** Logic errors, off-by-one errors, null handling
2. **Security:** Injection, XSS, auth bypasses, data exposure
3. **Performance:** N+1 queries, unnecessary allocations, missing caches
4. **Maintainability:** Code smells, naming, complexity
5. **Testing:** Missing test cases, brittle tests

Code to review:
```
{paste_code}
```

For each issue found, provide:
- Severity: 🔴 Critical / 🟡 Warning / 🔵 Info
- Category: Which of the 5 areas above
- Description: What's wrong and why
- Suggestion: How to fix it, with code example

End with an overall assessment and top 3 priorities.

Modèle 4 : conception de point d'accès API

Design a {http_method} {endpoint_path} endpoint for {resource_description}.

Framework: {framework}
Auth: {auth_method}
Database: {database}

The endpoint should:
- {functionality_1}
- {functionality_2}
- {functionality_3}

Provide:
1. Route definition with middleware chain
2. Request validation schema ({validation_library})
3. Controller/handler function
4. Service layer function
5. Database query/function
6. Response types (success and error)
7. Example curl request and response

Modèle 5 : migration de base de données

Create a database migration for {change_description}.

Current schema:
```
{current_schema}
```

Desired changes:
- {change_1}
- {change_2}

ORM: {orm_name}
Database: {database_type}

Requirements:
- Migration must be reversible (include down migration)
- Preserve existing data (write data migration SQL if needed)
- Add appropriate indexes for new columns
- Consider performance impact on large tables
- Include rollback safety checks

Modèle 6 : génération de suite de tests

Write a comprehensive test suite for {function_or_class_name}.

Testing framework: {framework}
Mocking library: {library}

Code under test:
```
{paste_code}
```

Test categories to cover:
- ✅ Happy path: All valid inputs produce correct outputs
- 🔄 Edge cases: Empty inputs, boundary values, null/undefined
- ❌ Error cases: Invalid inputs, permission denied, network failures
- 🏎️ Performance: Response time expectations for critical paths
- 🔒 Security: Auth checks, input sanitization

For each test:
- Use descriptive test names that read like documentation
- Follow Arrange-Act-Assert pattern
- Include setup/teardown for shared state
- Mock external dependencies

Modèle 7 : plan de refactorisation

You are a software architect specializing in {language} refactoring.

Current code:
```
{paste_current_code}
```

Problems with current code:
- {problem_1}
- {problem_2}

Refactor using {pattern_or_principle}.

Provide:
1. **Analysis:** What's wrong and why the current approach doesn't scale
2. **Target Architecture:** How the refactored code should be structured
3. **Step-by-step Plan:** Ordered refactoring steps (safe, incremental)
4. **Refactored Code:** Complete implementation
5. **Migration Guide:** How to transition from old to new without breaking changes
6. **Risk Assessment:** What could go wrong and how to mitigate

Modèle 8 : génération de documentation

Generate documentation for this {language} code:

```
{paste_code}
```

Documentation type: {JSDoc/TSDoc/Python docstrings/README section}

Requirements:
- Document all public functions/classes/methods
- Include parameter descriptions with types
- Include return type descriptions
- Add usage examples for non-obvious APIs
- Note any side effects or important caveats
- Use {style_guide} conventions

For README documentation, include:
- Overview (1-2 paragraphs)
- Installation instructions
- Quick start example
- API reference table
- Configuration options

Modèle 9 : optimisation des performances

You are a performance engineering specialist.

Analyze and optimize this code for performance:

```
{paste_code}
```

Current performance:
- {metric}: {current_value}
- Target: {target_value}
- Bottleneck suspected at: {location}

Optimization constraints:
- Must not change the public API
- Must maintain all existing test passes
- Must not sacrifice readability for micro-optimizations
- {additional_constraint}

Provide:
1. **Profiling Analysis:** Where time/memory is being spent
2. **Optimization Strategies:** Ranked by expected impact
3. **Optimized Code:** With comments explaining each change
4. **Benchmark Comparison:** Before vs after expected metrics
5. **Trade-offs:** Any readability or complexity costs

Modèle 10 : audit de sécurité

You are a security engineer specializing in {language}/{framework} security.

Perform a security audit on this code:

```
{paste_code}
```

Check for:
- Injection attacks (SQL, NoSQL, command, LDAP)
- Authentication and authorization bypasses
- Cross-site scripting (XSS) vulnerabilities
- Cross-site request forgery (CSRF) exposure
- Insecure direct object references (IDOR)
- Sensitive data exposure (logging, error messages)
- Insecure cryptography or key management
- Race conditions in concurrent operations
- Denial of service vulnerabilities

For each finding:
- Severity: Critical / High / Medium / Low
- OWASP Category: Which Top 10 category
- Description: Clear explanation of the vulnerability
- Attack Scenario: How an attacker would exploit it
- Remediation: Specific code fix
- Verification: How to confirm the fix works