Prompts Cursor pour développeurs : guide et exemples 2026

Cursor n'est pas « ChatGPT dans un éditeur ». C'est un IDE qui combine votre codebase, des fichiers ouverts, des règles projet (.cursorrules), et un modèle de langage (Claude, GPT-4o, Gemini selon config). Un prompt Cursor efficace mentionne la stack, les fichiers concernés, les conventions du repo, le périmètre exact du changement — sinon l'IA propose du code hors standards, trop large, ou qui casse ce qui fonctionnait.

Ce guide développeur couvre l'anatomie d'un prompt Cursor, les modes (Chat, Composer, Agent), des templates debug/feature/refactor, l'intégration R-C-T-C, et les erreurs qui coûtent des heures de revert Git.

Pourquoi les prompts Cursor diffèrent de ChatGPT web

Sur chat.openai.com, le modèle n'a pas votre repo. Dans Cursor, @file, @folder, @codebase injectent du contexte — mais seulement si vous le demandez explicitement et si le périmètre est clair. Un prompt « fix le bug » sans fichier ni message d'erreur force l'IA à deviner. Un prompt « fix dans auth.ts ligne 42, erreur JWT expired, respecte pattern refresh existant dans lib/auth » converge vite.

• Contexte code > contexte prose
• Périmètre fichiers explicite (touch / don't touch)
• Definition of done technique (types, tests, lint)
• Tâches atomiques : une feature ou un fix par session Composer
• Référence patterns existants du repo plutôt que patterns génériques Stack Overflow

Anatomie d'un prompt Cursor efficace (R-C-T-C dev)

1. Rôle : « Tu es dev [stack] senior, tu respectes les conventions de CE repo »
2. Contexte : framework, versions, @fichiers pertinents, état actuel
3. Tâche : verbe précis + livrable (composant, migration, fix, test)
4. Contraintes : fichiers interdits, pas de lib new, tests requis, étapes avant exécution

Dans Cursor, le meilleur prompt est celui qu'un reviewer humain pourrait exécuter sans poser de questions.

Modes Cursor : quand utiliser quoi

Chat (Cmd+L)

Questions, explications, petits snippets, review lecture. Prompt court avec @file ciblé. Pas pour refactor multi-fichiers.

Composer (Cmd+I)

Features multi-fichiers, refactors, génération structure. Prompt long structuré, liste fichiers attendus, ordre exécution. Demandez « liste plan + fichiers avant d'écrire » pour gros changements.

Agent / Yolo mode

Enchaînement autonome commandes + edits. Garde-fous stricts : périmètre, tests finaux, pas de rm -rf. Réservé tâches bien cadrées.

Templates prompts qui fonctionnent

Nouvelle feature

Ajoute [feature] dans @src/app/dashboard. Stack Next.js 15 App Router, TS strict, Tailwind, shadcn. Pattern similaire à @src/components/existing-widget.tsx. Ne modifie pas auth ni middleware. Étapes : 1) liste fichiers create/edit 2) implémente 3) vérifie types. Tests optionnels si [spec].

Debug

Erreur : [message complet]. Fichier @path/to/file.ts. Repro : [steps]. Hypothèse : [Y]. Propose 2 causes probables avec preuve dans le code, puis fix minimal. Explique en 3 lignes. Ne refactorise pas hors scope.

Refactor

Refactor @folder/utils en modules séparés par domaine. Conserve API publique exports. Pas de changement comportement — tests @tests/utils doivent passer. Plan migration fichiers d'abord, exécute après validation.

Code review IA

Review @PR diff comme senior [stack]. Checklist : sécurité, perf, types, naming repo, edge cases. Format : Critical / Suggestion / Nice. Pas de rewrite complet, commentaires actionnables.

Documentation

Documente @src/lib/api.ts pour dev junior. JSDoc fonctions publiques, exemple usage, erreurs possibles. Style concis, anglais technique OK.

.cursorrules et contexte persistant

Fichier .cursorrules à la racine : stack, conventions naming, patterns interdits, structure dossiers. Réduit répétition dans chaque prompt. Exemple : « Toujours App Router, jamais pages/. Composants client marqués use client. Préférer server actions. »

Erreurs fréquentes prompts Cursor

1. « Refais toute l'app » — scope explosion
2. Pas de @file → IA invente structure
3. Mélanger feature + debug + style dans un Composer
4. Accepter diff sans lire — régressions silencieuses
5. Ignorer types/lint errors post-génération
6. Copier prompt ChatGPT web sans contexte repo
7. Ne pas demander plan avant gros multi-file edit

Workflow recommandé feature complète

1. Spec en Chat : comportement attendu, edge cases
2. Composer plan : fichiers, data flow, composants
3. Validation plan humaine
4. Implémentation par sous-étapes si >5 fichiers
5. Run tests + lint + manual QA
6. Commit message généré depuis diff réel

Questions fréquentes (People Also Ask)

Quel modèle choisir dans Cursor ?

Claude Sonnet/Opus : code nuancé, gros contexte. GPT-4o : rapide, polyvalent. Testez sur VOTRE repo — différences varient selon stack.

Prompt Cursor en français ou anglais ?

Français OK pour instructions. Code et identifiants restent anglais. Commentaires code selon convention équipe.

Comment éviter que Cursor modifie trop de fichiers ?

Liste blanche : « Modifie UNIQUEMENT [fichiers]. Si autre fichier requis, demande permission. » Review diff file par file.

Cursor vs GitHub Copilot prompts ?

Copilot = complétion inline, prompts courts. Cursor Composer = tâches multi-fichiers, prompts structurés longs. Même discipline R-C-T-C, granularité différente.

Intégration CI et prompts Cursor

Pour équipes matures : documentez prompts types dans CONTRIBUTING.md — review PR, feature template, hotfix template. Les reviewers référencent le template au lieu de réécrire consignes ad hoc. Réduit variance qualité code généré entre devs.

Sécurité et prompts Cursor

Ne collez jamais secrets (.env, clés API, tokens prod) dans prompts même si Cursor promet privacy. Utilisez placeholders [API_KEY]. Pour code auth/payment : prompts explicites « security review OWASP top 10 sur ce diff » en plus du fix fonctionnel.

Prochaine étape

Framework R-C-T-C pour structure, 10 erreurs prompt IA pour pièges généraux, comment écrire prompt ChatGPT pour spec en amont de Cursor.

Guide approfondi : Composer pas à pas

Scénario réel : ajouter authentification OAuth Google à une app Next.js existante. Mauvais prompt : « Add Google login ». Bon prompt Composer en cinq lignes : contexte stack Next 15 + NextAuth v5 déjà partiellement configuré ; @fichiers auth.ts, middleware.ts, .env.example ; tâche — flow sign-in Google uniquement, pas Facebook ; contraintes — ne pas casser email/password existant, types stricts, redirect /dashboard ; process — liste fichiers et env vars requis AVANT edit. Résultat typique : plan 4 fichiers, implémentation incrémentale, moins de surprises.

Tests automatisés via prompts Cursor

Prompt type : « Génère tests Vitest pour @utils/format.ts couvrant happy path + 3 edge cases listés. Mock Date si nécessaire. Ne modifie pas implementation sauf bug avéré. » Séparez génération tests et fix code — deux prompts distincts réduisent scope creep.

Refactor legacy sans catastrophe

Legacy jQuery ou class components React : prompt « Strangler fig pattern — extrais [module] vers @new/path sans changer API exportée. Commit logique intermédiaire. Tests snapshot avant/après. » Cursor excelle quand migration est découpée, pas big bang.

• Toujours commit avant session Composer risquée
• Utiliser branches feature/cursor-* pour rollback facile
• Demander diff summary en fin de session
• Pair review humain obligatoire sur auth, payment, PII
• Mettre à jour .cursorrules après chaque pattern validé équipe

Stack typiques et prompts associés

React/Next : @components pattern, server vs client explicite. Python/FastAPI : pydantic models, pytest. Mobile React Native : platform-specific files. Précisez stack dans les 3 premières lignes de CHAQUE prompt Composer — Cursor ne devine pas votre monorepo. Monorepo Turborepo : indiquez package name @acme/ui vs @acme/web pour éviter edits wrong workspace.

Synthèse développeur Cursor

Prompts Cursor efficaces = contexte repo + tâche atomique + definition of done + review humaine. L'IA accélère frappe et exploration ; vous restez architecte et reviewer. Documentez templates équipe, commit avant Composer risqué, mesurez régression tests. Couplé R-C-T-C et 10 erreurs prompt, vous évitez 90% diffs revert.

FAQ développeurs Cursor

Quelle longueur prompt Cursor idéale ?

150-400 mots selon complexité. Référencez @files plutôt que coller code entier. Plan + exécution en 2 prompts pour features >3 fichiers.

Cursor génère code deprecated : comment éviter ?

Versions explicites dans .cursorrules et prompt. « Next.js 15 App Router only, pas pages router deprecated APIs. » Reject diff si imports obsolètes.

Prompt Cursor pour tests e2e Playwright ?

« Génère spec Playwright user flow login→dashboard. Page objects pattern. @e2e/existing.spec.ts style. Data-testid selectors. Pas hardcode wait arbitraires. »

Cas avancés Cursor

Migration database : prompt plan rollback + migration up/down + seed test. API design : OpenAPI spec first puis implémentation @routes. Performance : « profile bottleneck @hot-path, propose 2 optimisations mesurables sans premature optimization ailleurs. » Accessibility : « audit a11y @component, WCAG 2.1 AA, fixes priorités keyboard focus. » Chaque cas exige périmètre fichiers strict — jamais « improve entire app ».

Pair programming IA : vous driver, Cursor executor. Prompts courts fréquents beats monologue rare. Commit après chaque étape validée. Cette discipline transforme Cursor de roulette russe en outil fiable sprint après sprint.

Onboarding junior dev sur prompts Cursor

Formation 3 sessions : (1) lire .cursorrules + R-C-T-C (2) exercice debug guidé @file (3) feature micro-scope review senior. Interdire Composer wide scope première semaine. Checklist merge : lint, tests, diff size <200 lignes sauf validation lead. Documentez 5 prompts gold repo-specific Notion. Juniors productifs Cursor en 2 semaines vs 2 mois trial-error.

Lead dev : revue hebdomadaire prompts Composer équipe — patterns gagnants → .cursorrules update. Investissement 30 min/semaine compounding qualité codebase sur trimestres.

Ressources liées : structure R-C-T-C, 10 erreurs prompt IA, comment écrire prompt ChatGPT pour specs amont, PromptPilot variantes expert Cursor. Maîtrise prompts Cursor = productivité dev mesurable dès première semaine pratique disciplinée et review systématique.