12 conseils pour utiliser Cursor de façon plus intelligente

À la date du 23/06, et sur la base de mon expérience ainsi que d’un mélange de Reddit Cursor, de la communauté Cursor, des réseaux sociaux et de divers articles de blog. Les objections, critiques et discussions sont les bienvenues.

---

Conseil 1. Choisir son modèle de manière stratégique

• Les capacités de code, la vitesse et le coût varient selon les modèles, il est donc important de choisir en fonction du contexte.
• Les modèles Thinking (Claude 4, Gemini 2.5 Pro, etc.) sont plus autonomes mais plus lents.
• Les modèles Non-Thinking (GPT 4.1, etc.) suivent bien des instructions claires et sont plus rapides.
• Les modèles recommandés diffèrent selon le type de tâche (par ex. Sonnet pour des modifications simples, Opus pour une planification complexe).
• La fonction Auto-select étant peu fiable, mieux vaut essayer soi-même plusieurs modèles et trouver son propre style.

Conseil 2. Pour modifier une application complexe, commencer par planifier en mode Ask

• Le mode Agent modifie directement le code ; sur une application complexe, il peut donc casser des fonctionnalités existantes.
• Le mode Ask est un mode lecture seule qui ne modifie pas les fichiers, et il est très utile pour élaborer un plan.
• Le plus sûr est de discuter d’abord du plan avec l’IA en mode Ask, puis d’exécuter ensuite en mode Agent.
• En formulant clairement le prompt, par exemple « ne modifie rien tout de suite », on peut réduire les actions inutiles du mode Ask.
• Le mode Manual est moins utile, car il faut y indiquer soi-même les fichiers à référencer.

Conseil 3. En débogage, ne le laissez pas modifier les fichiers tout de suite : identifiez la cause avec des tests

• Si l’on confie directement la correction du bug à l’IA, on risque facilement d’enchaîner les échecs.
• Étape 1 (Agent) : lui faire d’abord écrire un test « en échec » qui reproduit le bug (approche TDD).
  • « Sur la page X, quand on clique sur Y, cela devrait se comporter comme A mais ça se comporte comme B. Je veux le corriger en TDD, donc écris et exécute un test qui reproduit ce phénomène. N’oublie pas qu’à ce stade le test doit échouer. Je peux aussi me tromper, donc si tu n’arrives pas à reproduire le problème, dis-le-moi. Ne commence pas à corriger le problème sans mon ordre. »
• Étape 2 (Ask) : lui faire expliquer les causes possibles et comment les vérifier afin d’identifier la cause racine.
  • « Je veux identifier la cause racine du bug. Propose les différentes raisons possibles pour lesquelles ce phénomène se produit, dans quelles conditions il apparaît, et explique aussi comment vérifier laquelle est la bonne. Dis-moi également quelles informations supplémentaires seraient utiles, quels logs il faudrait ajouter, etc. Tu n’as pas besoin d’exécuter ces méthodes, explique-les seulement. Si la cause a déjà été identifiée pendant l’écriture du test, explique-la. »
• Étape 3 (Agent) : verrouiller le test avec .cursorignore, puis lui demander de modifier le code jusqu’à ce que le test passe.
  • « Ajoute d’abord le test créé précédemment à .cursorignore. Ensuite, en partant des hypothèses les plus probables que tu as proposées, identifie progressivement la cause racine et organise le flux de fonctionnement idéal sous forme de flowchart. Puis, en t’appuyant sur ce flux idéal, modifie le code jusqu’à ce que le test passe. S’il y a quelque chose que je dois vérifier ou sur quoi je dois intervenir, dis-le-moi. »
• Il peut aussi être utile de définir des règles pour l’écriture des tests

Conseil 4. Laisser Cursor gérer lui-même ses règles pour qu’il devienne progressivement plus intelligent

• Si des échanges utiles ont eu lieu dans une session de chat, vous pouvez utiliser la fonction /Generate Cursor Rules.
• Il suffit de demander : « Crée ou modifie une Rule à partir de cette conversation. »
• C’est particulièrement utile après un débogage : si la cause d’un bug a été identifiée, on peut lui faire ajouter/modifier une Rule pour éviter de répéter la même erreur.
• Cela permet à Cursor d’apprendre, de se maintenir et de devenir progressivement plus intelligent.

Conseil 5. Améliorer sa productivité avec les onglets multiples et les options Auto

• Dans Cursor, on peut utiliser plusieurs onglets de chat en parallèle. Pendant qu’un Agent modifie du code dans un onglet, on peut faire autre chose en mode Ask dans un autre.
• En activant l’option Auto-run, l’exécution du terminal, l’écriture de fichiers, etc. se font automatiquement sans devoir tout approuver manuellement.
• En activant l’option Auto-Fix Lints, les erreurs de type et autres problèmes similaires sont corrigés automatiquement, ce qui est pratique.

Conseil 6. Ne pas faire durer trop longtemps une seule session de chat

• Quand une conversation devient trop longue, l’IA peut oublier des informations importantes à cause des limites de taille du contexte. (Cursor résume automatiquement.)
• Une fois une tâche terminée, il est plus avantageux de démarrer une nouvelle session de chat.
• Dans un nouveau chat, vous pouvez injecter le résumé d’une conversation précédente dans le contexte avec @Past Chats.
• Si les éléments utiles sont transformés en règles (conseil 4), le besoin de maintenir de longues conversations diminue.

Conseil 7. Dès qu’une modification significative est terminée, faire un commit

• Une fois une tâche terminée, il est important de prendre l’habitude de toujours faire un commit dans Git.
• Le commit est le minimum de filet de sécurité pour revenir en arrière si l’IA modifie mal le code.
• Via le chat de Cursor, vous pouvez obtenir de l’aide depuis la configuration initiale de Git jusqu’à la rédaction du message de commit.
  • « Je veux mettre cette codebase sur GitHub. Le problème, c’est que je ne connais rien à Git ni à GitHub et je n’ai même pas de compte. Je ne sais même pas si Git est installé. Aide-moi pas à pas. »
• La fonction AI Commit Message permet aussi de générer automatiquement un message de commit.

Conseil 8. Indiquer la structure du code à Cursor, et ajuster la longueur des fichiers ainsi que leur nom

• Il est utile de comprendre les caractéristiques des Tools internes de Cursor
  • List Directory ne lit pas le contenu des fichiers ; il ne lit que les noms de répertoires et de fichiers
  • Read File ne lit au maximum que 250 lignes d’un fichier à la fois (750 en mode Max)
  • Si la taille d’un fichier ou d’un répertoire référencé est trop importante, tout n’est pas inclus : seules les parties jugées importantes, comme les appels de fonctions, sont conservées sous forme compressée
  • Dans une même session de chat, on ne peut appeler les Tools que 25 fois ; pour aller plus loin, il faut cliquer soi-même sur Continue (même si l’option Auto apply edit est activée. En mode Max, on peut aller jusqu’à 200 sans Continue)
• Il est donc préférable de donner aux fichiers et répertoires des noms explicites quant à leur rôle, et de maintenir la longueur des fichiers sous les 500 lignes.
• Si la structure clé des répertoires ou les informations sur les composants sont ajoutées dans une règle Always Applied, l’IA n’aura pas besoin de les réexplorer à chaque fois.
• Vous pouvez lui demander de créer une documentation de la structure du code et de l’ajouter comme règle.
  • « Crée un document qui te permette de comprendre d’un coup d’œil la structure de cette codebase et ses fichiers importants. Tu peux utiliser un diagramme mermaid. Ensuite, ajoute-le comme règle de projet appropriée. Mets AlwaysApply: true. »

Conseil 9. Quand un fichier devient trop long, laisser Cursor le modulariser

• Si un fichier devient trop long, mieux vaut demander à l’IA de le modulariser.
• Étape 1 (Ask) : « Si l’on devait modulariser ce projet, sous quels angles ou avec quelles stratégies serait-ce pertinent ? Par exemple : 1) point de vue Layered Architecture 2) point de vue AOP 3) point de vue FSD 4) point de vue Clean Architecture »
• Étape 2 (Ask) : « En combinant les stratégies que tu as proposées, élabore un plan de modularisation pertinent. »
• Étape 3 (Agent) : « Documente ce plan puis exécute-le. »

Conseil 10. Utiliser @ pour injecter activement du contexte

• En utilisant le symbole @ pour injecter directement différents contextes, au-delà des fichiers et dossiers, l’IA travaille mieux.
• @Code : permet de référencer seulement une partie précise du code, comme une fonction ou une variable.
• @Docs : permet de s’appuyer sur la documentation officielle d’une bibliothèque pour écrire un code plus précis. Cursor dispose déjà de certaines docs, et l’on peut aussi en ajouter via une URL.
• @Git : permet de référencer le contenu d’une branche ou d’un commit précis pour comparer ou faire expliquer des changements.
• @Web, @Link : permettent d’effectuer une recherche web ou de lire le contenu d’un lien spécifique.
• @Recent Change : permet de référencer les changements récents dans la codebase. Je n’ai pas trouvé son fonctionnement exact, mais cela semble reposer sur les unstaged changes et les commits récents. Cela paraît utile pour les non-développeurs qui ne gèrent pas leurs commits de façon très stricte.

Conseil 11. Si la sécurité est importante, activez le mode Privacy

• Si le mode Privacy n’est pas activé, des données comme le code ou les prompts peuvent être collectées et utilisées pour l’entraînement des modèles.
• En activant le mode Privacy, une partie du code peut être chiffrée et temporairement stockée, mais elle n’est ni conservée de façon permanente ni utilisée pour l’entraînement.
• En revanche, certaines fonctions récentes, comme l’agent en arrière-plan, ne sont pas disponibles en mode Privacy.
• Pour plus de détails, consultez la documentation où Cursor explique le mode Privacy

Conseil 12. Utiliser les MCP et outils qui rendent le développement plus confortable et plus précis

• Pour la gestion des tâches, je recommande Memory Bank, TaskMaster et Vooster.
• Les MCP de la documentation officielle de Cursor peuvent être installés directement via deep link
  • Browserbase pour lancer un navigateur, cliquer, lire la console, prendre des captures d’écran, etc.
  • PlayWright pour ajouter des tests E2E
  • Sentry pour surveiller et corriger les erreurs
  • Stripe et Paypal pour les paiements
  • Netlify et Heroku pour le déploiement
  • Snyk et Semgrep pour les contrôles de sécurité
  • Supabase pour lire et écrire dans les tables de la base de données → ce n’est pas mentionné dans la documentation officielle de Cursor, mais à mon avis c’est une installation indispensable pour les vibe coders
• Si vous travaillez en entreprise et que vous devez bien expliquer le contexte de l’entreprise ou de plusieurs produits, il peut aussi être judicieux de développer directement votre propre MCP. (Référence : Working with Documentation)
• Vous pouvez aussi utiliser des outils externes comme StageWise pour pointer une partie précise de l’UI et demander une correction de bug, par exemple.

Autres petites astuces

• Mode Max : la facturation se fait au token et non à la requête, avec un contexte plus large et davantage d’utilisation des Tools.
• Ajout de modèles : dans les paramètres, on peut activer des modèles cachés par défaut, comme Claude 4 Opus.
• Custom API Key : fonction permettant de brancher sa propre clé d’API LLM. L’utilité reste plutôt limitée. À noter que même dans ce cas, le trafic passe forcément par les serveurs de Cursor.
• Synchronisation des paramètres : la synchronisation des paramètres entre plusieurs PC n’est pas encore vraiment bien prise en charge officiellement. Il est rapporté que l’export/import de profil fonctionne mal, et une extension est sortie il y a quelques semaines, mais au 23/06 elle présente encore plusieurs problèmes
  • Elle apparaît bien sur la marketplace VSCode, mais n’est pas trouvable dans la liste des extensions de Cursor
  • On peut l’installer dans VSCode puis l’importer avec la fonction Import VSCode Settings and Extensions de Cursor. En revanche, l’extension ne s’initialise pas correctement en pratique (issue liée)
  • L’idée semble bonne, donc j’espère que le développeur corrigera ça rapidement

[elddytbt]

Les conseils 4 et 6 sont bien ~~

J’ai une question : pour moi, 500 par mois, c’est absurdement peu. Comment résolvez-vous ce problème ?

[spilist2]

La limite récente n’a-t-elle pas été levée ?

J’utilise aussi Claude Code, et comme j’essaie surtout de formuler des demandes affinées après avoir suffisamment discuté dans AI Studio + de configurer des règles + d’implémenter moi-même si nécessaire avec l’autocomplétion par onglet, etc., j’ai rarement eu l’impression que cela manquait.

[fanotify]

Faut-il obligatoirement prendre un abonnement payant pour utiliser ces fonctionnalités ? Ou bien, si l’usage reste faible, est-ce que les membres gratuits peuvent aussi les suivre ?

[spilist2]

D’après mon expérience, Cursor est assez avare en fonctionnalités et en quota sur son offre gratuite, donc je pense qu’il n’est pas facile à utiliser gratuitement.

Il existe des modèles utilisables sans payer, mais ils ne sont pas très bons non plus pour coder.

[eususu]

Ces conseils sont vraiment excellents.
Merci !

[dnltmdwhd]

Il y a aussi beaucoup de contenus utiles que je ne connaissais pas~ Merci !

[jk34011]

Merci pour ces bons conseils~ J’en apprends beaucoup.

[dkmin]

Merci pour ce partage très instructif. =b

« Cependant, en mode Privacy, certaines fonctionnalités récentes comme les agents en arrière-plan ne peuvent pas être utilisées. »
=> J’aimerais avoir des précisions concrètes. Une source, s’il vous plaît...

ref.
https://docs.cursor.com/background-agent

Background Agents are available in Privacy Mode. We will never train on your code, and we will only retain code for the purposes of running the agent. Learn more about Privacy mode

[spilist2]

Ah, jusqu'à il y a peu, ce n'était pas utilisable, mais ça a changé !! Merci.

[baeba]

Dans mon cas,
avant que l’IA ne modifie le code source ou avant de poser une question dans le prompt,
je sauvegarde toujours l’intégralité du code source en local.
Sous ./history/
./hisrory/r0001/
./hisrory/r0002/ ...
je crée des répertoires avec ce type de structure et j’exécute un script qui sauvegarde les sources de développement.

Comme mon environnement de développement est sous Windows, c’est un fichier ps1.

# backup.ps1  
$base = "./src"  
$history = "./history"  
  
# Trouver le dossier rXXXX le plus récent  
$latest = Get-ChildItem -Path $history -Directory | Where-Object { $_.Name -match '^r\d{4}$' } | Sort-Object Name -Descending | Select-Object -First 1  
if ($latest) {  
    $num = [int]($latest.Name.Substring(1)) + 1  
} else {  
    $num = 1  
}  
$next = "r{0:D4}" -f $num  
$dest = "$history/$next"  
  
# Créer les dossiers de sauvegarde  
New-Item -ItemType Directory -Path "$dest" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/css" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/js" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/html" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/images" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/doc" -Force | Out-Null  
New-Item -ItemType Directory -Path "$dest/server" -Force | Out-Null  
  
# Copier les fichiers/dossiers  
Copy-Item "$base/SPA_index.html" "$dest/SPA_index.html"  
Copy-Item "$base/css/*" "$dest/css/" -Recurse  
Copy-Item "$base/js/*" "$dest/js/" -Recurse  
Copy-Item "$base/images/*" "$dest/images/" -Recurse  
Copy-Item "$base/doc/*" "$dest/doc/" -Recurse  
  
# Copier les fichiers serveur : exclure node_modules  
Copy-Item "$base/server/*" "$dest/server/" -Recurse -Exclude "node_modules"  
  
Write-Host "Sauvegarde terminée : $dest"  

[spilist2]

Quels sont les avantages et les inconvénients de cette méthode par rapport à l’utilisation de Git ?

[baeba]

J’utilise aussi Git en même temps..
Comme l’IA peut modifier énormément le code source quand on développe réellement..
Même si on vérifie tout ça soigneusement point par point, des erreurs ou des bugs peuvent apparaître au moment du build,
à cause de ça..

C’est pratique quand on veut revenir à l’ancien code.

On peut aussi rollback le code avec Git, mais comme tout le code est sauvegardé en entier,
ça m’a aidé à retrouver rapidement les changements de code et à avancer dans l’implémentation en les regardant.

[turastory]

Il semble que l'utilisation de git subtree pourrait être une bonne idée.

[lux1024]

git worktree ?

[turastory]

Ah, j’ai confondu le nom haha, c’est bien worktree.

[spilist2]

Merci pour votre réponse !

[joyoo]

Il n’y a absolument aucun avantage… Les systèmes de gestion de versions ont justement été créés pour éviter ce genre de pratique.
À mon avis, vous feriez mieux d’étudier davantage Git.

[nakyup]

Le MCP appelé context7 est utile, donc je l’utilise souvent quand je pose des questions sur l’utilisation d’une bibliothèque.

[spilist2]

Ah, je viens de me rappeler que j’avais oublié de présenter ça. J’ai donc mis à jour le support de cours, mais pas le blog. C’est maintenant ajouté, merci.

[aqqnucs]

Astuce 2, question. En mode ask, est-ce qu’il tente quand même de modifier si on ne lui dit pas explicitement de ne pas le faire ?

[spilist2]

Oui, il arrive qu’en essayant de faire une modification, on dépasse le délai d’expiration et que edit_files ne fonctionne plus, puis qu’on passe à autre chose.

[kissdesty]

Même sans effectuer de modification réelle, cela semble signifier que, même en mode Ask, cela réduit les actions préparatoires inutiles juste avant une modification.