Accueil › Cursor › Composer

Cursor Composer : l’édition multi-fichiers propulsée par l’IA

Cursor Composer est la fonctionnalité qui distingue Cursor de tous les autres éditeurs. Elle permet de créer et modifier plusieurs fichiers simultanément à partir d’une instruction en langage naturel. Décrivez ce que vous voulez, Composer génère les diffs, et vous acceptez ou rejetez chaque modification.

Si le Chat (Cmd+L) est un assistant qui répond à vos questions et l’édition inline (Cmd+K) est un outil chirurgical pour les modifications ciblées, le Composer est un directeur de projet qui orchestre des modifications complexes sur plusieurs fichiers. C’est la fonctionnalité qui rend Cursor environ 40% plus rapide que VS Code + Copilot pour les développeurs qui expédient des features, selon les retours de la communauté. Avec le lancement de Composer 2 en mars 2026 (le propre modèle de code de Cursor), cette fonctionnalité est devenue encore plus puissante et moins coûteuse.

Qu’est-ce que Composer exactement ?

Composer est l’interface de Cursor pour les tâches d’édition qui impliquent plusieurs fichiers ou des modifications structurelles dans un projet. Contrairement au Chat (qui répond à des questions) ou à l’édition inline (qui modifie un bloc de code sélectionné), Composer comprend votre projet dans son ensemble et peut créer, modifier et supprimer des fichiers de manière coordonnée.

Concrètement, vous ouvrez Composer avec Cmd+I, vous décrivez ce que vous voulez en langage naturel, et Cursor :

Analyse votre instruction et identifie les fichiers concernés. Planifie les modifications nécessaires. Génère les diffs pour chaque fichier. Vous présente un aperçu des changements avec un diff visuel. Vous laisse accepter ou rejeter chaque modification individuellement.

C’est cette boucle « instruction > planification > diff > validation » qui distingue Composer d’un simple chatbot qui crache du code. Chaque changement est traçable, révisable et réversible.

Les trois modes de Composer

Mode Normal : vous spécifiez les fichiers

Dans le mode Normal, vous indiquez explicitement quels fichiers Composer doit modifier en utilisant les mentions @. Par exemple : @auth.ts @middleware.ts Ajoute la vérification du token JWT dans le middleware et mets à jour les types dans auth. Composer ne touche que les fichiers mentionnés.

Ce mode est idéal quand vous savez exactement quels fichiers sont impliqués. C’est le plus prévisible et le plus sûr : pas de modifications surprises dans des fichiers non mentionnés.

Mode Agent : Composer explore librement

Le mode Agent est la version la plus puissante (et la plus impressionnante) de Composer. Au lieu de spécifier les fichiers, vous décrivez une tâche de haut niveau et laissez Cursor naviguer dans votre codebase pour trouver et modifier les fichiers pertinents. L’Agent peut aussi exécuter des commandes dans le terminal (builds, tests, installations de packages), lire la sortie, et ajuster son approche en fonction des résultats.

Exemple d’instruction Agent : « Ajoute l’authentification Google OAuth au projet. Crée la page de connexion, l’endpoint API, le middleware, les migrations de base de données, et les tests unitaires. » L’Agent analyse la structure du projet, identifie le framework utilisé, crée les fichiers nécessaires, installe les dépendances, et produit un résultat complet. Chaque étape est trackée par Git, ce qui permet un rollback à n’importe quel point.

Le mode Agent consomme plus de crédits que le mode Normal (plus de tokens sont utilisés pour la navigation, la planification et l’exécution des commandes). Réservez-le aux tâches qui justifient cette autonomie.

Cloud Agents : Composer sans votre machine

Lancés début 2026, les Cloud Agents exécutent les tâches de Composer sur l’infrastructure cloud de Cursor plutôt que sur votre machine locale. Ils clonent votre dépôt GitHub, travaillent sur une branche séparée dans une VM cloud, et poussent une PR quand c’est terminé. Vous pouvez lancer 10 à 20 Cloud Agents en parallèle, chacun enregistrant des logs, captures d’écran et vidéos de son travail.

Les Cloud Agents sont accessibles depuis le navigateur, le mobile, ou même Slack. C’est un changement de paradigme : vous lancez une tâche le matin, et la PR est prête quand vous arrivez à votre bureau. Le mode Cloud Agent est disponible sur les plans Pro+ et Ultra, et nécessite le Max Mode (qui ajoute un surcoût de ~20% sur les tokens).

Composer 2 : le modèle propriétaire de Cursor

En mars 2026, Cursor a lancé Composer 2, son propre modèle de code entraîné exclusivement sur des données de code. Ce n’est pas un modèle généraliste : c’est un modèle spécialisé pour les modifications multi-fichiers, le refactoring et les chaînes de tâches longues dans un IDE.

Composer 2 offre une fenêtre de contexte de 200 000 tokens, optimisée pour les tâches CLI de coding. Les benchmarks annoncés par Cursor le placent au niveau de Claude Opus 4.6 sur les tâches de coding pratiques, tout en coûtant nettement moins cher :

Composer 2 est 3 à 10 fois moins cher que Claude Opus ou GPT-5.4 pour des performances de coding proches. C’est un signal stratégique fort de Cursor : en développant son propre modèle, l’entreprise réduit sa dépendance à OpenAI et Anthropic tout en offrant un meilleur rapport qualité/prix à ses utilisateurs.

Composer 2 est disponible en alpha dans Cursor. Vous pouvez le sélectionner dans le menu déroulant des modèles du Composer. Pour les tâches de coding pur (pas de rédaction, pas de Q&A), c’est souvent le meilleur choix en termes de rapport performance/coût.

Bonnes pratiques pour tirer le maximum de Composer

Soyez précis dans vos instructions

Composer fonctionne mieux avec des instructions détaillées. Au lieu de « Ajoute l’authentification », préférez « Ajoute l’authentification JWT avec refresh tokens. Utilise bcrypt pour le hash des mots de passe. Crée un middleware qui vérifie le token sur les routes protégées. Stocke les tokens dans des cookies httpOnly. Ajoute les routes /auth/login, /auth/register et /auth/refresh. »

Plus vous êtes précis, moins Composer fait de suppositions, et moins vous avez d’itérations de correction.

Utilisez le Plan Mode (Shift+Tab)

Avant de laisser Composer générer du code, activez le Plan Mode avec Shift+Tab. L’Agent analyse votre projet, planifie les modifications, et vous présente un plan avant de coder. Vous pouvez valider, ajuster ou rejeter le plan. C’est beaucoup plus efficace que de laisser l’Agent coder directement puis de corriger les erreurs.

Les plans sont sauvegardés en Markdown dans .cursor/plans/, ce qui vous permet de les réutiliser, les partager avec l’équipe, ou les reprendre plus tard.

Configurez des .cursorrules spécifiques

Les fichiers .cursorrules sont particulièrement importants pour Composer. Sans eux, Composer fait des choix de conventions génériques. Avec des règles précises, il respecte votre stack, votre style de code et vos contraintes projet. Incluez les conventions de nommage, le framework, les patterns architecturaux, les bibliothèques à utiliser (ou à éviter), et les exigences de test.

Révisez chaque diff

Composer présente un diff visuel pour chaque fichier modifié. Prenez le temps de lire chaque diff avant d’accepter. Sur les modifications multi-fichiers complexes, Composer peut introduire des incohérences entre fichiers (un import ajouté dans un fichier mais pas dans un autre, un type modifié à un endroit mais pas partout). La revue de diff est votre filet de sécurité.

Décomposez les tâches complexes

Pour les modifications très larges (refactoring architectural, migration de framework), décomposez en étapes séquentielles plutôt que de tout demander en une fois. « Étape 1 : extrais le service d’authentification dans un module séparé. Étape 2 : migre les routes pour utiliser le nouveau service. Étape 3 : ajoute les tests. » Chaque étape produit des diffs plus lisibles et plus faciles à valider.

Choisissez le bon modèle par tâche

Le choix du modèle dans Composer impacte la qualité et le coût. Voici une recommandation par type de tâche :

Exemples concrets d’utilisation

Ajouter une feature complète

Ajoute un système de notifications en temps réel :
- Créer un composant NotificationBell dans /components
- Ajouter un endpoint WebSocket dans /api/ws
- Créer un service NotificationService avec les méthodes subscribe/unsubscribe
- Ajouter les migrations pour la table notifications (user_id, message, read, created_at)
- Intégrer le composant dans le header existant
- Ajouter les tests unitaires pour le service

Composer crée les fichiers nécessaires, modifie le header existant, et produit des diffs pour chaque changement. Vous révisez et acceptez.

Refactoring architectural

Refactorise le module de paiement :
- Extrais l'interface PaymentGateway commune
- Implémente StripeGateway et PayPalGateway
- Utilise le pattern Strategy dans PaymentService
- Mets à jour tous les usages existants dans le codebase
- Ajoute les types TypeScript appropriés

Migration technologique

Convertis ces 5 composants React de class components vers des functional components avec hooks :
@UserList.tsx @UserDetail.tsx @UserForm.tsx @UserSearch.tsx @UserSettings.tsx
- Remplace this.state par useState
- Remplace componentDidMount par useEffect
- Conserve exactement le même comportement
- Ajoute les types de props avec interfaces

Génération de tests

Génère les tests unitaires pour le module de paiement :
@PaymentService.ts @StripeGateway.ts @PayPalGateway.ts
- Utilise Jest et des mocks pour les appels API
- Couvre les cas de succès, d'échec, et les cas limites (montant négatif, devise invalide)
- Ajoute un test d'intégration pour le workflow complet
- Structure les tests avec describe/it et des noms explicites en français

Composer excelle dans la génération de tests car il comprend le code source et peut produire des tests qui couvrent les cas limites réels, pas seulement les happy paths. C’est souvent l’un des usages les plus rentables de Composer : rédiger des tests est fastidieux pour un humain, mais rapide et systématique pour l’IA.

Documentation de code

Ajoute la documentation JSDoc complète à tous les fichiers du dossier /services :
- Description de chaque fonction
- @param avec types et descriptions
- @returns avec type et description
- @throws pour les erreurs possibles
- @example avec un exemple d'utilisation réaliste

Pour la documentation, Composer analyse le code existant et produit des JSDoc/docstrings contextuellement pertinentes. C’est nettement plus précis qu’un outil de documentation générique car Composer comprend les relations entre les fichiers du projet.

Composer vs les alternatives

Composer n’est pas la seule solution pour l’édition multi-fichiers IA, mais c’est la plus intégrée dans un IDE :

Claude Code offre des capacités agentiques similaires mais en ligne de commande (terminal), pas dans un IDE graphique. Pour les développeurs qui préfèrent le terminal, c’est une excellente alternative. Claude Code utilise exclusivement les modèles Claude d’Anthropic.

GitHub Copilot Workspace propose aussi l’édition multi-fichiers, mais avec une intégration moins profonde dans l’IDE que Composer. L’avantage de Copilot est son prix ($10/mois vs $20 pour Cursor Pro) et son intégration native avec GitHub.

OpenAI Codex est un agent de coding cloud qui travaille de manière asynchrone, similaire aux Cloud Agents de Cursor. Codex est orienté vers les tâches longues et les PR automatisées, tandis que Composer offre un feedback plus immédiat avec le diff visuel.

L’avantage principal de Composer reste l’intégration directe dans l’éditeur : vous voyez les diffs en temps réel, vous pouvez accepter/rejeter fichier par fichier, et le contexte de votre codebase est automatiquement disponible via l’indexation de Cursor.

Limites à connaître

Composer est puissant mais pas infaillible. Les modifications très larges (touchant 10+ fichiers) peuvent introduire des incohérences. Relisez toujours les diffs. Le mode Agent peut parfois s’emballer et modifier des fichiers non pertinents. Utilisez le mode Normal quand vous savez exactement quels fichiers sont concernés. Le contexte standard de 200K tokens peut être insuffisant pour les très gros projets. Activez le Max Mode pour des contextes étendus (avec surcoût). Composer consomme des crédits de votre pool mensuel quand vous utilisez des modèles premium. Le mode Auto et Composer 2 sont les options les plus économiques.

Verdict

Composer est la raison principale pour laquelle les développeurs passent de VS Code à Cursor. L’édition multi-fichiers par instruction en langage naturel change fondamentalement la vitesse à laquelle on implémente des features. Avec le lancement de Composer 2, Cursor a aussi réduit le coût de cette fonctionnalité de 3 à 10x par rapport aux modèles tiers.

Conseil : commencez par des tâches de complexité moyenne (2-3 fichiers) en mode Normal. Familiarisez-vous avec le workflow instruction > diff > validation. Ensuite, passez au mode Agent pour les tâches plus ambitieuses. La courbe d’apprentissage est courte, mais la discipline de revue de diff est essentielle pour éviter les mauvaises surprises.