Mode Agent Cursor en pratique : 10 astuces après trois mois d'usage

Je fixe le cinquième fichier erroné que l’Agent vient de générer. Troisième refactor de cette fonction ce soir. Je me demande si ce mode Agent, vendu pour « accomplir des tâches complexes automatiquement », est là pour aider ou pour me torturer.

Il y a trois mois, en découvrant l’interrupteur Agent dans Cursor, j’étais aussi excité que devant un nouveau continent. Le rêve : une demande, et l’IA crée les fichiers, installe les dépendances, écrit le code, corrige les bugs — il ne reste qu’à boire un café. La réalité : il travaille bien, souvent pour tout casser.

Après trois mois d’essais, notre relation est passée de « amour-haine » à « entente solide ». C’est mon meilleur assistant — à condition de savoir le piloter. Cet article partage les pièges et les leçons apprises.

Qu’est-ce que le mode Agent : la différence avec le Chat classique

Dans le Composer de Cursor, un interrupteur « Agent » apparaît en haut à droite. Ne le sous-estimez pas : l’activer, c’est donner des mains à l’IA.

En mode classique, l’IA ne fait que conseiller : « ajoutez une fonction ici », « ce bug vient peut-être de… », et vous intervenez. En mode Agent, elle agit : créer des fichiers, modifier le code, installer des paquets npm, lancer des commandes — d’un bloc.

Ça a l’air génial ? C’est aussi le piège. Imaginez un stagiaire qui modifie le code : il travaille, mais vous découvrez qu’il a touché d’autres fichiers et changé la logique centrale. L’Agent, c’est ce stagiaire zélé mais peu fiable.

Ma règle : petites questions en Chat (« explique ce code »), opérations multi-fichiers en Agent (« ajoute les types TypeScript à tous les composants »). Savoir quand lâcher prise et quand surveiller de près.

Astuce 1 : l’art du découpage — ne pas tout avaler d’un coup

Ma plus grosse erreur : une tâche énorme en une seule fois.

Je voulais migrer un vieux projet de JavaScript vers TypeScript, optimiser les perfs et ajouter une connexion. Résultat : création frénétique de fichiers, le projet ne démarre plus. Une journée entière à rollback.

Depuis, je découpe :

1. Tour 1 : « ajoute les types TypeScript aux fichiers de src/components »
2. Tour 2 : « traite les définitions de types dans src/utils »
3. Tour 3 : « configure tsconfig.json pour compiler correctement »

À chaque étape, je lance les tests avant de continuer. En cas d’erreur, je sais où chercher.

Astuce : limiter chaque tâche à 3-5 fichiers. Au-delà, l’Agent perd le fil. Vous ne demanderiez pas à un stagiaire de modifier 20 fichiers d’un coup — même logique.

Astuce 2 : le contexte — dire à l’Agent quoi regarder

L’Agent ne sait pas quels fichiers comptent. Des milliers de fichiers, node_modules inclus : tout scanner, c’est lent et bruyant.

Avant chaque tâche Agent, deux réflexes :

Étape 1 : configurer .cursorignore

Ce fichier indique ce qu’il ne faut pas indexer. Mon modèle :

node_modules/
dist/
build/
.next/
.git/
*.log
coverage/

Gain de vitesse souvent supérieur à 30 %. Sur une journée, ça se sent.

Étape 2 : références @ précises

Pour cibler un fichier : @nomFichier. Exemple : « en t’inspirant de @api.ts, ajoute la gestion d’erreurs à @user.ts ». L’Agent ne fouille plus partout.

Une fois sans @, j’ai dit « en t’inspirant du fichier API » — il a trouvé un vieux fichier de deux ans et a appliqué un pattern obsolète. Souvenir amer.

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

Astuce 3 : le contrôle de version, votre bouée de sauvetage

Leçon apprise à la dure.

Un vendredi après-midi, j’ai demandé un refactor de module avant une réunion. Retour : 30 fichiers modifiés. « Efficace », ai-je pensé. Le soir, la connexion était cassée.

Problème : je ne savais plus quels fichiers avaient changé.

Trois heures de comparaison fichier par fichier. Depuis, règle absolue : git commit avant l’Agent.

Mon flux :

# Sauvegarde avant de commencer
git add .
git commit -m "Sauvegarde avant Agent"

# Puis laisser l'Agent travailler

# Vérifier après
git diff

En cas d’erreur : git reset --hard et on recommence. Sauvé maintes fois.

Autre astuce : une fonctionnalité à la fois, commit juste après. Rollback léger en cas de souci. Comme les sauvegardes fréquentes en jeu.

Astuce 4 : savoir dire stop — ne pas laisser creuser

Une fois lancé, l’Agent va jusqu’au bout. Même en erreur, il continue — et empire.

Cas extrême : dépendance introuvable → il en invente une fausse, puis code dessus. Une dizaine de fichiers touchés avant que je m’en aperçoive.

Je supervise maintenant :

• Erreur rouge ? ESC immédiatement
• Fichier bizarre créé ? Stop
• Logique centrale modifiée à tort ? Arrêt net

Ensuite j’évalue :

• Partiellement OK → garder, ajuster l’instruction
• Dévié → git reset, nouvelle consigne

N’hésitez pas à interrompre. L’Agent n’est pas humain. Le laisser finir une logique fausse coûte bien plus cher.

Astuce 5 : ne jamais faire confiance aveuglément au code de l’Agent

La qualité ressemble à une boîte surprise — parfois excellente, parfois catastrophique.

Au début, je pensais : « l’IA est si intelligente, le code doit être bon. » Deux pannes en test m’ont rappelé que la revue est obligatoire.

Après chaque tâche Agent :

Étape 1 : tests

npm test

Basique, mais oublié souvent. L’Agent ne lance pas les tests pour vous.

Étape 2 : checklist de revue

• ✓ Logique : le comportement est-il correct ?
• ✓ Cas limites : null, exceptions
• ✓ Performance : goulots évidents
• ✓ Style : conventions du projet
• ✓ Sécurité : injection SQL, XSS, etc.

Étape 3 : raccourcis de l’Agent

Demander « optimiser les requêtes BDD » peut se résumer à un cache sans toucher au SQL. Vérifier ce qui a vraiment changé.

Une fois, une logique métier complexe était remplacée par // TODO: à implémenter. Malin — le trou reste pour moi.

Astuce 6 : l’Agent dans les grands projets

Sur un petit repo, l’Agent fait des miracles. Sur un gros : centaines de fichiers, dépendances complexes, styles d’équipe — il se perd facilement.

Projet Next.js : 200+ composants. « Optimise les perfs de tous les composants » → dix minutes à chercher des fichiers, quelques changements mineurs, rien sur le cœur.

Ma méthode pour les gros projets :

Stratégie 1 : par module

• « Traiter uniquement src/components/auth »
• « Modifier seulement le code lié à la connexion »

Attention concentrée, moins de bruit.

Stratégie 2 : .cursorrules

À la racine :

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

# Règles du projet
- Tous les composants en TypeScript
- Appels API via @/lib/api
- Ne pas modifier @/lib/core
- Nouveaux fichiers avec commentaires JSDoc

Comme un guide pour stagiaire — pas garanti à 100 %, mais une référence.

Stratégie 3 : modules indépendants en priorité

Utilitaires, composants génériques : faible impact si erreur, fort bénéfice si réussi.

Astuce 7 : Agent et Composer, la combinaison gagnante

Agent et Composer ne s’excluent pas — ils se complètent.

En bref : Composer = atelier, Agent = interrupteur d’automatisation.

Scénario 1 : refactor multi-fichiers = Composer + Agent ON

Exemple : « ajouter gestion d’erreurs et retry à tous les appels API ». L’Agent brille sur le lot transversal.

Scénario 2 : modification profonde mono-fichier = Composer + Agent OFF

Logique complexe d’un composant : Agent off, suggestions manuelles, contrôle étape par étape.

Scénario 3 : question rapide = Chat

« Que signifie cette erreur ? » ou « comment optimiser ce bout ? » — Chat suffit.

Astuce : basculer l’interrupteur Agent en cours de route. Agent ON pour démarrer, OFF si ça dérape — pas de tunnel.

Astuce 8 : pièges à éviter absolument

Quelques erreurs fréquentes — pas interdites, mais à peser deux fois.

Piège 1 : laisser l’Agent toucher la base de données

« Nettoie les doublons en base de test » — il a aussi effacé la prod. Pourquoi ? .env pointait vers la prod ; il ne change pas d’environnement pour vous.

Leçon : BDD en manuel, ou sauvegarde d’abord.

Piège 2 : remplacer un motif dans tous les fichiers d’un coup

« Remplacer var par let partout » — parfois aussi dans les commentaires, chaînes, voire des libs. Code qui tourne, diff bizarre.

Mieux : un répertoire, vérifier, puis élargir.

Piège 3 : Agent sans tests

Vieux projet sans tests, gros refactor Agent — beau à l’œil, trois fonctions cassées en prod. Sans tests, invisible.

Soit écrire des tests, soit petits pas et vérif manuelle.

Piège 4 : dépendance excessive

Le pire piège mental : « je demande à l’Agent » pour tout, y compris nommer une variable. L’Agent augmente ; il ne remplace pas la réflexion.

Astuce 9 : accélérer l’Agent

Parfois lent pour peu de fichiers. Quelques leviers :

Astuce 1 : réduire l’index

.cursorignore en base. Dans les réglages, limiter l’index Codebase à src/, lib/ — exclure docs et configs.

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

Astuce 2 : nettoyer l’historique de chat

Long contexte = revue lente à chaque tour. Après une grosse tâche, nouvelle conversation. Panier vidé.

Astuce 3 : modèle plus rapide

GPT-4 par défaut : qualité, lenteur. Renommage ou formatage : Claude Sonnet ou GPT-3.5 — souvent deux fois plus vite.

Ma règle : logique complexe → GPT-4 ; tâches simples → modèle rapide.

Astuce 4 : lots plutôt que tout d’un coup

100 fichiers à commenter : 5 lots de 20, contrôle entre chaque. Détection précoce, contexte plus léger, exécution plus rapide.

Comme une requête SQL : pas de full scan si on peut filtrer.

Astuce 10 : ma checklist Agent

Avant chaque session, je parcours :

Avant de démarrer :

• ✓ Git commité, working tree propre
• ✓ .cursorignore en place
• ✓ Portée claire (quels fichiers)
• ✓ Bonne branche (pas main en direct)
• ✓ Environnement de test prêt

Pendant l’exécution :

• ✓ Surveiller les logs, stop si anomalie
• ✓ Suivre les changements de fichiers
• ✓ ESC si dérive
• ✓ Tâches complexes en étapes

Après la tâche :

• ✓ git diff sur tout
• ✓ npm test
• ✓ Revue logique, perf, sécurité
• ✓ Commit local après validation
• ✓ Nettoyer l’historique de chat si besoin

Fastidieux sur le papier, salvateur en pratique. Comme la checklist pilote avant décollage.

Règle d’or : jamais de gros changement Agent un vendredi après-midi. Week-end à corriger des bugs — expérience que je ne recommande à personne.

Conclusion

Retour à 2 h du matin et cinq fichiers erronés. Aujourd’hui, l’Agent ne part plus en vrille : je sais quand lâcher prise et quand stopper, comment découper et borner. L’Agent n’est pas magique — un outil à apprivoiser.

Trois mois pour ces 10 astuces. Le mode Agent peut doubler l’efficacité — si vous apprenez à collaborer. Stagiaire énergique mais inexpérimenté : bonne direction = gros progrès ; abandon total = chaos.

Conseil : n’ayez pas peur des erreurs, gardez un rollback sous la main. Petites tâches d’abord, confiance progressive. La complicité vient avec le temps.

Dernier mindset : l’Agent renforce vos capacités, il ne remplace pas votre réflexion. Pensez d’abord, puis décidez si l’Agent aide. Vous restez aux commandes.

Si vous débutez avec Cursor Agent, configurez Git en premier. Ce n’est pas une blague — pouvoir revenir en arrière libère l’expérimentation.

Bonne collaboration avec votre Agent. Si vous avez vos astuces ou vos galères, partagez-les en commentaire — éviter les pièges ensemble vaut mieux que chacun dans son coin.