Utiliser le mode YOLO dans Cursor pour une itération rapide

Le mode YOLO (You Only Live Once) dans Cursor accepte automatiquement tous les diffs et modifications générés par l'IA sans nécessiter d'approbation manuelle pour chacun. Cela accélère considérablement les tâches répétitives et les workflows de confiance, mais comporte des risques. Ce guide couvre comment utiliser le mode YOLO en toute sécurité et efficacement.

Qu'est-ce que le mode YOLO ?

Le mode YOLO permet :

• Acceptation automatique des diffs - Les modifications IA sont appliquées immédiatement
• Itération plus rapide - Pas besoin de cliquer sur "Accepter" pour chaque modification
• Opérations par lots - Appliquer plusieurs modifications en séquence
• Friction réduite - Rester en état de flux plus longtemps

Quand utiliser le mode YOLO

Bons cas d'usage

Scénario	Pourquoi YOLO fonctionne
Ajouter des commentaires JSDoc	Faible risque, prévisible
Renommer des variables	Facile à vérifier avec la recherche
Formater le code	Sûr, réversible
Ajouter des types	Le compilateur attrape les erreurs
Refactoriser les imports	L'IDE met en évidence les problèmes
Écrire des tests	Le testeur valide
Mettre à jour les fichiers de config	Généralement simple

Éviter YOLO pour

Scénario	Niveau de risque
Modifications d'authentification	Critique
Migrations de base de données	Critique
Traitement des paiements	Critique
Modifications de contrat API	Élevé
Grandes modifications architecturales	Élevé
Déploiements en production	Critique
Suppression de fichiers	Élevé

Activer le mode YOLO

Méthode 1 : Paramètres

{
  "cursor.yoloMode": true,
  "cursor.autoAcceptDiffs": true,
  "cursor.autoApplyChanges": true
}

Méthode 2 : Palette de commandes

1. Appuyez sur Cmd/Ctrl + Shift + P
2. Tapez "YOLO Mode"
3. Sélectionnez Basculer le mode YOLO

Méthode 3 : Commande de chat

/yolo

Ou :

Activer le mode YOLO pour cette session

Méthode 4 : Raccourci clavier

// keybindings.json
{
  "key": "cmd+shift+y",
  "command": "cursor.toggleYoloMode"
}

Configuration du mode YOLO

Paramètres YOLO sécurisés

{
  "cursor.yoloMode": true,
  "cursor.autoAcceptDiffs": true,
  
  // Limites de sécurité
  "cursor.yolo.maxFilesPerSession": 20,
  "cursor.yolo.maxLinesChanged": 500,
  "cursor.yolo.requireTestsPass": true,
  "cursor.yolo.excludePatterns": [
    "src/auth/**",
    "src/payment/**",
    "src/database/migrations/**",
    "**/*.env*",
    "config/production/**"
  ],
  
  // Paramètres de sauvegarde automatique
  "cursor.yolo.autoSaveBeforeApply": true,
  "cursor.yolo.createGitCheckpoint": true
}

YOLO par projet

Créez .cursor/yolo-config.json :

{
  "enabled": true,
  "safePatterns": [
    "src/components/**/*.tsx",
    "src/hooks/**/*.ts",
    "src/utils/**/*.ts",
    "tests/**/*.ts"
  ],
  "unsafePatterns": [
    "src/auth/**",
    "src/api/**",
    "src/database/**"
  ],
  "maxChangesPerFile": 50,
  "requireReviewFor": [
    "*.config.*",
    "*.env*",
    "Dockerfile"
  ]
}

Workflows YOLO sécurisés

Workflow 1 : Sprint de documentation

[YOLO ON] Ajouter des commentaires JSDoc à toutes les fonctions dans src/utils/
Suivre le style existant de src/utils/helpers.ts

Attendu : 15-20 fichiers modifiés, tous les commentaires ajoutés Vérification : Vérifier quelques fichiers

Workflow 2 : Migration TypeScript

[YOLO ON] Ajouter des types TypeScript à src/components/
Utiliser les interfaces de src/types/
Conserver le comportement d'exécution existant

Attendu : Types ajoutés, aucune modification de logique Vérification : Exécuter tsc --noEmit

Workflow 3 : Génération de tests

[YOLO ON] Écrire des tests unitaires pour src/services/user.ts
Suivre le modèle dans tests/services/auth.test.ts
Couvrir toutes les méthodes publiques

Attendu : Nouveau fichier de test créé Vérification : Exécuter les tests avec npm test

Workflow 4 : Nettoyage des imports

[YOLO ON] Organiser les imports dans src/pages/
Grouper : React, libs externes, internes, types
Supprimer les imports inutilisés

Attendu : Imports propres, aucun changement fonctionnel Vérification : L'application se construit toujours

Mesures de sécurité

1. Points de contrôle Git

Créez toujours un point de contrôle avant YOLO :

# Créer une branche de point de contrôle YOLO
git checkout -b yolo/task-name

# Committer l'état actuel
git add -A && git commit -m "checkpoint: before YOLO session"

2. Révision après YOLO

Après la session YOLO :

# Réviser toutes les modifications
git diff

# Vérifier les fichiers modifiés
git diff --stat

# Exécuter les tests
npm test

# Si quelque chose ne va pas, revenir en arrière
git checkout -- .

3. YOLO avec tests

Configurez pour YOLO uniquement si les tests passent :

{
  "cursor.yolo.requireTestsPass": true,
  "cursor.yolo.testCommand": "npm test",
  "cursor.yolo.stopOnTestFailure": true
}

4. Limites de taille de fichier

{
  "cursor.yolo.maxFileSizeKB": 100,
  "cursor.yolo.maxFilesPerChange": 10,
  "cursor.yolo.maxLinesPerFile": 200
}

Commandes du mode YOLO

Commandes de chat

Commande	Action
/yolo on	Activer le mode YOLO
/yolo off	Désactiver le mode YOLO
/yolo status	Vérifier l'état YOLO
/yolo safe	YOLO uniquement pour les motifs sûrs
/yolo full	YOLO complet (tous les fichiers)

Commandes de session

[yolo on] Ajouter la gestion des erreurs à tous les points de terminaison API

[yolo safe] Refactoriser les props de composants pour utiliser des interfaces

[yolo off] Attends, laisse-moi d'abord réviser cette dernière modification

Mesurer l'efficacité de YOLO

Suivez ces métriques :

Métrique	Sans YOLO	Avec YOLO
Temps par tâche	15-30 min	5-10 min
Clics par modification	3-5	0
Changements de contexte	Élevé	Faible
Taux d'erreur	Faible	Légèrement plus élevé
Taux de revert	Faible	5-10%

Directives YOLO d'équipe

Quand l'équipe devrait utiliser YOLO

• Mises à jour de style de code
• Améliorations de documentation
• Ajout de types
• Refactorisation d'utilitaires internes
• Écriture de tests

Quand YOLO est interdit

• Correctifs en production
• Modifications liées à la sécurité
• Modifications de schéma de base de données
• Modifications de version API
• Modifications de configuration

Template de PR pour les modifications YOLO

## Session YOLO

### Tâche
[Décrire ce que la session YOLO a fait]

### Fichiers modifiés
- [x] Toutes les modifications révisées
- [x] Les tests passent
- [x] Aucun fichier sensible modifié

### Vérification
- [x] Vérification manuelle terminée
- [x] Tests automatisés passent
- [x] Aucune régression détectée

### Rollback
```bash
git revert HEAD

## Mode YOLO + Autres fonctionnalités

### YOLO + Agents en arrière-plan

[Background, YOLO ON] Ajouter des types à tous les fichiers dans src/models/

### YOLO + Modes personnalisés

```json
{
  "name": "Safe YOLO",
  "systemPrompt": "You are in YOLO mode but with safety constraints. Only modify: .tsx components, .ts utilities, and tests. Never modify: auth, payment, or database files. Always add types, never remove them.",
  "tools": {
    "write": true,
    "edit": true
  }
}

YOLO + Mode Plan

[PLAN MODE] Planifier le refactoring
[Review plan]
[YOLO ON] Exécuter le plan approuvé

Pièges courants de YOLO

Piège	Prévention
YOLO sur les mauvais fichiers	Utiliser excludePatterns
Trop de modifications	Définir maxFilesPerSession
Modifications cassantes	Exiger le passage des tests
Perte de suivi	Créer des points de contrôle git
Problèmes de sécurité	Exclure les fichiers auth/payment

Liste de vérification de sécurité YOLO rapide

Avant de commencer une session YOLO :

• Branche de point de contrôle git créée
• Configuration YOLO révisée
• Tâche confirmée comme sûre pour YOLO
• Répertoires sensibles exclus
• Les tests peuvent être exécutés après
• Plan de rollback prêt

Après la session YOLO :

• Diff révisé avec git diff
• Tests exécutés
• Fichiers clés vérifiés
• Commité ou reverté

Ressources connexes

• Cursor Agent Mode Masterclass
• Plan vs Act Dual-Mode Workflow
• RIPER-5 Advanced Constraint Mode
• Cursor Self-Review Hooks Guide