Outils de code d’IA agentique

Les assistants de programmation par IA ont évolué : de simples outils d’autocomplétion, ils sont devenus des agents autonomes capables de planifier, de modifier plusieurs fichiers, d’exécuter des tests et de créer des pull requests. Ce tutoriel présente les trois principaux outils : Claude Code, Cursor et GitHub Copilot.

1) Qu’est-ce qui rend un outil « agentique » ?

Les outils traditionnels de complétion de code par IA suggèrent les quelques lignes suivantes. Les outils agentiques vont plus loin :

Capacité	Autocomplétion	Agentique
Portée	Ligne ou fonction actuelle	Ensemble de la base de code
Planification	Aucune	Raisonnement en plusieurs étapes
Exécution	Suggestions uniquement	Peut modifier des fichiers et exécuter des commandes
Contexte	Fichier actuel	Compréhension de l’ensemble du dépôt
Flux de travail	Réactif	Exécution autonome des tâches

Les outils agentiques peuvent comprendre toute la structure de votre projet, planifier des modifications dans plusieurs fichiers, les appliquer, exécuter des tests et itérer jusqu’à ce que la tâche soit terminée.

2) Comparaison rapide : Claude Code, Cursor et Copilot

Fonctionnalité	Claude Code	Cursor	GitHub Copilot
Interface	CLI, web, extensions d’IDE	IDE complet (fork de VS Code)	Extensions d’IDE
Fenêtre de contexte	Grande (Opus à contexte long)	Indexation de tout le dépôt	Plus petite, en amélioration
Modifications multifichiers	Performant	Excellent	En amélioration
Mode Plan	Oui	Oui	Oui (plus récent)
Tarification	Formules Pro/Max	Crédits + abonnement	Abonnement
Idéal pour	Architecture, refactorisations importantes	Développement interactif	Programmation en ligne

3) Principes fondamentaux de Claude Code

Claude Code fonctionne avec Opus 4.8 (son modèle par défaut actuel) et de grandes fenêtres de contexte. Installez-le et authentifiez-vous :

bash

# Installer Claude Code (programme d’installation natif recommandé)
curl -fsSL https://claude.ai/install.sh | bash

# Ou avec npm (nécessite Node 18+)
npm install -g @anthropic-ai/claude-code

# S’authentifier : exécutez claude et suivez l’invite dans le navigateur
claude

# Démarrer dans votre projet
cd your-project
claude

Commandes de base

bash

# Poser une question sur votre base de code
claude "Comment l’authentification est-elle implémentée ici ?"

# Générer du code
claude "Ajoute un middleware de limitation de débit"

# Refactorisation multifichier
claude "Renomme UserService en AuthService dans toute la base de code"

# Créer une pull request
claude "Crée une pull request qui ajoute la validation des entrées à tous les endpoints d’API"

Configuration du projet

Placez le contexte du projet dans un fichier CLAUDE.md à la racine de votre dépôt. Claude Code le lit automatiquement au début de chaque session :

markdown

# Notes du projet

- Langage : TypeScript, formaté avec Prettier
- Tests : Vitest, dans tests/
- Ne pas modifier node_modules/ ni dist/

Les paramètres lisibles par machine (autorisations des outils, variables d’environnement, hooks) se placent dans .claude/settings.json. Par exemple, pour exiger une approbation avant l’exécution d’outils destructifs, configurez-y les autorisations.

Mémoire et contexte

Le contexte persistant du projet se trouve dans les fichiers CLAUDE.md, que Claude Code charge au début de chaque session, ainsi que dans une mémoire automatique que Claude met lui-même à jour en fonction de vos corrections et préférences. Pour lui fournir un contexte durable, modifiez CLAUDE.md plutôt que d’envoyer une instruction ponctuelle commençant par « Souviens-toi : » :

markdown

# CLAUDE.md
Ceci est un monorepo. Le code partagé se trouve dans packages/.

Utilisez la commande /clear au cours d’une session pour réinitialiser le contexte de travail.

4) Fonctionnalités agentiques de l’IDE Cursor

Cursor est conçu autour de flux de travail agentiques. Voici ses principales fonctionnalités :

Mode Agent

Appuyez sur Cmd+Shift+I (Mac) ou Ctrl+Shift+I (Windows/Linux) pour ouvrir Composer en mode Agent :

Flux de travail du mode Agent :
1. Décrivez votre tâche
2. L’agent crée un plan
3. Vous l’approuvez ou le modifiez
4. L’agent applique les modifications
5. Vérifiez et itérez

Mode Plan

Pour les tâches complexes, utilisez explicitement le mode Plan :

@plan Ajoute une authentification utilisateur avec :
- Des jetons JWT
- La rotation des jetons d’actualisation
- Le hachage des mots de passe avec bcrypt
- La limitation des tentatives de connexion

L’agent va :

Étudier votre code existant
Créer un plan d’implémentation détaillé
Attendre votre approbation
L’exécuter étape par étape

Injection de contexte

Utilisez @ pour ajouter un contexte précis :

@file src/api/auth.ts
@folder src/middleware
@docs https://jwt.io/introduction

Implémente un middleware de vérification JWT en suivant ces modèles

Agents parallèles

Exécutez plusieurs agents simultanément sur différentes branches :

# Dans Cursor :
1. Ouvrez la palette de commandes
2. "Cursor: New Agent in Worktree"
3. Chaque agent travaille de façon isolée
4. Comparez les résultats côte à côte

Cursor 3 a ajouté une fenêtre Agents (ouvrez-la avec Cmd+Shift+P, puis « Agents Window ») qui exécute plusieurs agents en parallèle dans des copies de travail locales, des worktrees git et des environnements cloud. La commande /worktree place chaque agent dans son propre worktree git isolé, tandis que /best-of-n exécute la même tâche avec plusieurs modèles afin que vous puissiez comparer les résultats côte à côte.

Règles de cohérence

Créez .cursor/rules/project.mdc :

markdown

# Règles du projet

## Style du code
- Utiliser le mode strict de TypeScript
- Privilégier les composants fonctionnels
- Utiliser des exports nommés, pas d’export par défaut

## Tests
- Chaque fonctionnalité doit avoir des tests
- Utiliser des blocs describe/it
- Simuler les services externes

## Sécurité
- Ne jamais committer de secrets
- Valider toutes les entrées utilisateur
- Utiliser des requêtes paramétrées

5) Fonctionnalités agentiques de GitHub Copilot

Copilot a évolué au-delà de l’autocomplétion :

Copilot Chat

Ouvrez le panneau de discussion et utilisez les commandes slash :

/explain - Expliquer le code sélectionné
/fix - Corriger les problèmes de la sélection
/tests - Générer des tests
/doc - Ajouter de la documentation

Agent de programmation (d’une issue à une pull request)

# Sur GitHub :
1. Ouvrez une issue GitHub
2. Attribuez-la à "Copilot"
3. L’agent de programmation travaille en arrière-plan :
   il analyse l’issue, modifie les fichiers et exécute les tests
4. Il ouvre une pull request afin que vous puissiez la vérifier

Cela se distingue du mode Agent de Copilot dans l’IDE, qui travaille de manière synchrone à vos côtés dans VS Code ou JetBrains.

Copilot répartit désormais son travail autonome en deux modes : le mode Agent s’exécute de manière synchrone dans votre IDE (VS Code et JetBrains), choisit les fichiers à modifier, exécute des commandes dans le terminal et itère sur les erreurs ; l’agent de programmation s’exécute de manière asynchrone dans le cloud, prend en charge une issue qui lui est attribuée et fournit une pull request pendant que vous travaillez sur autre chose.

Suggestions en ligne avec contexte

Copilot lit votre base de code. Aidez-le avec des commentaires :

typescript

// Middleware d’authentification qui :
// - Extrait le JWT de l’en-tête Authorization
// - Valide la signature du jeton
// - Associe l’utilisateur à la requête
// - Renvoie 401 si le jeton est invalide
export function authMiddleware(req, res, next) {
  // Copilot génère l’implémentation
}

6) Bonnes pratiques pour tous les outils

Rédigez des prompts clairs

❌ Mauvais : "Corrige le bug"

✅ Bon : "Corrige l’exception de pointeur nul dans UserService.getById
lorsque l’utilisateur n’existe pas. Renvoie null au lieu de lever une exception."

❌ Mauvais : "Ajoute des tests"

✅ Bon : "Ajoute des tests unitaires pour CartService couvrant :
- L’ajout d’articles à un panier vide
- La suppression d’articles
- Le calcul des totaux avec des remises
- Cas limite : quantités négatives"

Utilisez le mode Plan pour les tâches complexes

Pour toute tâche touchant au moins 3 fichiers, toujours :

1. Demander d’abord un plan
2. Examiner le plan
3. L’approuver ou le modifier
4. Laisser l’agent l’exécuter
5. Vérifier les modifications avant de committer

Fournissez le contexte architectural

Avant tout travail important, présentez l’architecture à l’agent :

"Il s’agit d’une architecture de microservices :
- api-gateway : achemine les requêtes
- auth-service : JWT, sessions
- user-service : CRUD des utilisateurs
- notification-service : e-mails, notifications push

Les services communiquent via le système pub/sub de Redis.
La base de données est PostgreSQL avec l’ORM Prisma."

Développement piloté par les tests avec des agents

1. Écrire d’abord un test qui échoue :
   "Écris un test d’inscription utilisateur qui vérifie la validation de l’adresse e-mail"

2. Laisser l’agent voir le test qui échoue :
   "Implémente l’inscription pour faire réussir ce test"

3. Itérer jusqu’à ce que tous les tests réussissent :
   "Corrige les derniers échecs de tests"

7) Considérations de sécurité

Les outils agentiques disposent de véritables pouvoirs. Définissez des limites :

Étapes d’approbation

json

// .claude/config.json
{
  "safety": {
    "requireApproval": [
      "rm",
      "git push",
      "npm publish",
      "database migrations",
      "env file changes"
    ]
  }
}

Environnements isolés

bash

# Exécuter les agents dans des environnements isolés
docker run -v $(pwd):/workspace -it claude-sandbox

# Ou utiliser des worktrees git pour les isoler
git worktree add ../feature-branch feature-branch

Fichiers sensibles

# .cursorignore / .claudeignore
.env
.env.*
secrets/
credentials/
*.pem
*.key

Vérifiez toutes les modifications

bash

# Avant d’accepter les modifications de l’agent :
git diff --stat
git diff

# Utiliser l’ajout interactif à l’index
git add -p

# Ne jamais fusionner automatiquement sans vérification

8) Modèles de flux de travail efficaces

Modèle 1 : Explorer, planifier, exécuter

Session 1 : "Comment fonctionne le système de paiement ?"
            → L’agent explore, vous apprenez

Session 2 : "Que faudrait-il faire pour ajouter Stripe ?"
            → L’agent crée un plan

Session 3 : "Implémente l’intégration de Stripe"
            → L’agent exécute le plan

Modèle 2 : Exploration parallèle

# Dans Cursor avec des agents parallèles :

Agent 1 : "Implémente la mise en cache avec Redis"
Agent 2 : "Implémente la mise en cache avec Memcached"
Agent 3 : "Implémente la mise en cache avec un cache LRU en mémoire"

→ Comparez les implémentations et choisissez la meilleure approche

Modèle 3 : Migration progressive

Étape 1 : "Identifie toutes les utilisations de l’API obsolète"
Étape 2 : "Crée un adaptateur pour la nouvelle API"
Étape 3 : "Migre le module A pour utiliser l’adaptateur"
Étape 4 : "Migre le module B..."
...
Étape N : "Supprime l’adaptateur et utilise directement la nouvelle API"

Modèle 4 : Développement de fonctionnalités guidé par les tests

1. "Écris des tests d’acceptation pour la modification du profil utilisateur"
2. "Écris des tests unitaires pour la validation du profil"
3. "Implémente la fonctionnalité pour faire réussir les tests"
4. "Ajoute des tests d’intégration"
5. "Refactorise pour améliorer la clarté"

9) Quel outil utiliser selon la situation

Situation	Outil recommandé
Programmation en temps réel, aide en ligne	GitHub Copilot
Refactorisations importantes, architecture	Claude Code
Session de développement complète	Cursor
Questions rapides sur le code	N’importe quelle interface de discussion
Création de pull requests à partir d’issues	Copilot Workspace
Modifications complexes sur plusieurs fichiers	Cursor Agent
Conception d’API, documentation	Claude Code
Découverte d’une nouvelle base de code	Cursor ou Claude Code

10) Mesurer l’efficacité

Suivez ces indicateurs pour évaluer les outils agentiques :

javascript

const metrics = {
  // Productivité
  suggestionsAccepted: 'pourcentage de suggestions conservées',
  timeToFeature: 'nombre d’heures entre le début et la fusion de la pull request',
  linesPerHour: 'vélocité du code (à utiliser avec prudence)',
  
  // Qualité
  bugsIntroduced: 'défauts attribués au code généré par l’IA',
  testCoverage: 'couverture du code généré par l’IA',
  reviewChanges: 'ampleur de vos modifications des suggestions de l’IA',
  
  // Coût
  apiCosts: 'dépenses mensuelles en outils d’IA',
  creditsUsed: 'crédits Cursor consommés',
  
  // Apprentissage
  newPatternsLearned: 'techniques apprises grâce à l’IA',
  codebaseUnderstanding: 'mesure dans laquelle l’IA vous a aidé à apprendre',
}

11) Pièges fréquents

Accorder une confiance excessive à l’agent

❌ Accepter des modifications importantes sans vérification
❌ Laisser les agents exécuter des commandes destructives
❌ Ne pas comprendre le code avant de le mettre en production

✅ Vérifier chaque modification
✅ Comprendre ce que vous livrez
✅ Utiliser les agents comme collaborateurs, pas comme remplaçants

Pollution du contexte

❌ Prompts énormes contenant du contexte non pertinent
❌ Ne pas effacer le contexte entre des tâches sans rapport
❌ Inclure les fichiers générés dans le contexte

✅ Garder les prompts ciblés
✅ Utiliser des références @file précises
✅ Exclure les artefacts de compilation

Ambiguïté des prompts

❌ "Améliore-le"
❌ "Corrige les problèmes"
❌ "Ajoute quelques tests"

✅ "Réduis la complexité temporelle de O(n²) à O(n log n)"
✅ "Gère le cas null à la ligne 45 avec un retour anticipé"
✅ "Ajoute des tests pour les cas limites : entrée vide, longueur maximale, Unicode"

12) Liste de vérification pour démarrer

markdown

## Liste de vérification de la configuration

### Claude Code
- [ ] Installer la CLI : `npm install -g @anthropic/claude-code`
- [ ] S’authentifier : `claude login`
- [ ] Créer `.claude/config.json`
- [ ] Ajouter `.claudeignore` pour les fichiers sensibles

### Cursor
- [ ] Télécharger depuis cursor.com
- [ ] Importer les paramètres de VS Code
- [ ] Configurer `.cursor/rules/`
- [ ] Apprendre le raccourci `Cmd+Shift+I` pour le mode Agent

### GitHub Copilot
- [ ] Installer l’extension dans votre IDE
- [ ] Activer Copilot Chat
- [ ] Essayer Copilot Workspace pour les issues
- [ ] Configurer `.github/copilot-instructions.md`

### Tous les outils
- [ ] Configurer des étapes d’approbation pour les opérations destructives
- [ ] Créer des fichiers d’exclusion pour les secrets
- [ ] Établir un flux de vérification
- [ ] Suivre les indicateurs dès le premier jour

À découvrir aussi

Publier un jeu web qui se charge rapidement
Web Workers pour la logique de jeu
Game jams et hackathons — les outils de code par IA transforment ce qu’il est possible d’accomplir pendant une game jam de 48 heures
Comparatif des moteurs de jeux web — choisir un moteur adapté aux flux de travail assistés par l’IA

Outils de code d’IA agentique ​

1) Qu’est-ce qui rend un outil « agentique » ? ​

2) Comparaison rapide : Claude Code, Cursor et Copilot ​

3) Principes fondamentaux de Claude Code ​

Commandes de base ​

Configuration du projet ​

Mémoire et contexte ​

4) Fonctionnalités agentiques de l’IDE Cursor ​

Mode Agent ​

Mode Plan ​

Injection de contexte ​

Agents parallèles ​

Règles de cohérence ​

5) Fonctionnalités agentiques de GitHub Copilot ​

Copilot Chat ​

Agent de programmation (d’une issue à une pull request) ​

Suggestions en ligne avec contexte ​

6) Bonnes pratiques pour tous les outils ​

Rédigez des prompts clairs ​

Utilisez le mode Plan pour les tâches complexes ​

Fournissez le contexte architectural ​

Développement piloté par les tests avec des agents ​

7) Considérations de sécurité ​

Étapes d’approbation ​

Environnements isolés ​

Fichiers sensibles ​

Vérifiez toutes les modifications ​

8) Modèles de flux de travail efficaces ​

Modèle 1 : Explorer, planifier, exécuter ​

Modèle 2 : Exploration parallèle ​

Modèle 3 : Migration progressive ​

Modèle 4 : Développement de fonctionnalités guidé par les tests ​

9) Quel outil utiliser selon la situation ​

10) Mesurer l’efficacité ​

11) Pièges fréquents ​

Accorder une confiance excessive à l’agent ​

Pollution du contexte ​

Ambiguïté des prompts ​

12) Liste de vérification pour démarrer ​

À découvrir aussi ​

Outils de code d’IA agentique

1) Qu’est-ce qui rend un outil « agentique » ?

2) Comparaison rapide : Claude Code, Cursor et Copilot

3) Principes fondamentaux de Claude Code

Commandes de base

Configuration du projet

Mémoire et contexte

4) Fonctionnalités agentiques de l’IDE Cursor

Mode Agent

Mode Plan

Injection de contexte

Agents parallèles

Règles de cohérence

5) Fonctionnalités agentiques de GitHub Copilot

Copilot Chat

Agent de programmation (d’une issue à une pull request)

Suggestions en ligne avec contexte

6) Bonnes pratiques pour tous les outils

Rédigez des prompts clairs

Utilisez le mode Plan pour les tâches complexes

Fournissez le contexte architectural

Développement piloté par les tests avec des agents

7) Considérations de sécurité

Étapes d’approbation

Environnements isolés

Fichiers sensibles

Vérifiez toutes les modifications

8) Modèles de flux de travail efficaces

Modèle 1 : Explorer, planifier, exécuter

Modèle 2 : Exploration parallèle

Modèle 3 : Migration progressive

Modèle 4 : Développement de fonctionnalités guidé par les tests

9) Quel outil utiliser selon la situation

10) Mesurer l’efficacité

11) Pièges fréquents

Accorder une confiance excessive à l’agent

Pollution du contexte

Ambiguïté des prompts

12) Liste de vérification pour démarrer

À découvrir aussi