Cursor Skills, Commands et Rules : Quelle est la différence ?

Cursor a trois fonctionnalités qui se chevauchent mais sont distinctes et qui confusent beaucoup d'utilisateurs : Skills, Commands et Rules. Le fil du forum avec 11 réponses posait essentiellement la même question de différentes manières -- "Lequel j'utilise pour quoi ?" Ce guide trace des frontières claires entre eux et vous montre quand utiliser chacun.

Définitions

Commençons par ce que chaque fonctionnalité est réellement.

Que sont les Rules ?

Les Rules disent à l'IA de Cursor comment se comporter quand elle génère ou modifie du code. Elles définissent les standards de codage, les conventions, les contraintes et les préférences.

Les Rules sont déclaratives -- vous déclarez ce qui devrait être vrai, et l'IA le suit.

Exemple de Rule
Toujours utiliser le mode strict TypeScript.
Préférer les exports nommés aux exports par défaut.
Utiliser des composants fonctionnels avec hooks, pas de composants classe.

Les Rules s'appliquent automatiquement à chaque interaction IA dans le projet où elles sont configurées. Vous ne les invoquez pas manuellement.

Où vivent les rules :

Rules globales : Settings > General > Rules for AI
Rules de projet : Fichier .cursorrules à la racine du projet
Rules scoped : Fichiers .mdc dans le répertoire .cursor/rules/

Que sont les Commands ?

Les Commands sont des prompts prédéfinis que vous invoquez manuellement pour effectuer des actions spécifiques. Ce sont des raccourcis pour les tâches courantes.

Les Commands sont impératives -- vous les déclenchez pour faire quelque chose de spécifique maintenant.

Exemple d'invocation de Command
Vous tapez : "/explain"
Résultat : L'IA explique le code sélectionné

Vous tapez :
"/fix"
Résultat : L'IA corrige les erreurs dans le code sélectionné

Les Commands sont des actions utilisateur explicites. L'IA ne les utilise pas à moins que vous ne le lui disiez.

Où vivent les commands :

Commands intégrées : /explain, /fix, /doc, /test, etc.
Commands personnalisées : Définies par l'utilisateur dans les paramètres

Que sont les Skills ?

Les Skills sont des capacités contextuelles que l'IA de Cursor peut mobiliser quand c'est nécessaire. Elles représentent des connaissances de domaine ou des capacités spécialisées que l'IA peut appliquer à vos requêtes.

Les Skills sont adaptatives -- l'IA décide quand les utiliser basé sur votre prompt.

Exemple de Skill en action
Utilisateur : "Configurez un projet Next.js avec TypeScript, Tailwind et Prisma"

L'IA utilise son skill "Next.js project scaffolding" pour :
- Exécuter les commandes d'initialisation correctes
- Configurer Tailwind correctement
- Configurer Prisma avec le bon emplacement de schéma
- Configurer les paths TypeScript

Vous n'invoquez pas explicitement les skills. L'IA reconnaît quand un skill s'applique et l'utilise automatiquement.

D'où viennent les skills :

Intégrés dans l'entraînement de l'IA de Cursor
Appris de votre codebase au fil du temps
Ajoutés via des serveurs MCP (Model Context Protocol)

Comparaison côte à côte

Aspect	Rules	Commands	Skills
Objectif	Définir les standards de comportement	Exécuter des actions spécifiques	Appliquer des connaissances de domaine
Quand appliqué	Automatiquement, toujours	Quand invoqué manuellement	Quand l'IA détecte la pertinence
Contrôle utilisateur	Configuré une fois, s'applique toujours	Déclenché à la demande	Implicite, l'IA décide
Format	Texte / JSON / .mdc	Commandes slash (`/fix`)	Capacité interne de l'IA
Portée	Globale ou spécifique au projet	Universelle	Dépendante du contexte
Exemple	"Utiliser des points-virgules"	`/explain selection`	"Sait comment générer des apps React"

Quand utiliser chacun

Utilisez les Rules quand

Vous voulez changer comment l'IA écrit le code de manière cohérente à travers votre projet.

Bons cas d'usage pour les rules :

Imposer un style de codage (tabs vs espaces, conventions de nommage)
Spécifier les préférences de stack technique (React vs Vue, Prisma vs Drizzle)
Définir des contraintes architecturales (pas d'imports circulaires, structure de dossiers spécifique)
Définir le style de réponse ("soyez concis", "ajoutez toujours des commentaires")

Exemple .cursorrules
{
  "techStack": ["Next.js 14", "TypeScript", "Tailwind CSS"],
  "rules": [
    "Utiliser les server components par défaut",
    "Ajouter 'use client' uniquement quand l'interactivité est nécessaire",
    "Toutes les routes API vont dans app/api/",
    "Utiliser Prisma pour toutes les opérations de base de données"
  ]
}

astuce

Les Rules sont la "constitution" de votre projet. Écrivez-les une fois et elles guident chaque interaction IA.

Utilisez les Commands quand

Vous voulez effectuer une action spécifique maintenant sur du code sélectionné ou le contexte actuel.

Bons cas d'usage pour les commands :

Expliquer du code inconnu (/explain)
Corriger une erreur spécifique (/fix)
Générer de la documentation (/doc)
Écrire des tests pour une fonction (/test)
Refactoriser un bloc sélectionné (/refactor)

Workflow de command
Sélectionnez la fonction que vous voulez documenter
Tapez /doc dans le chat
L'IA génère des commentaires JSDoc pour cette fonction

Référence des commands intégrées :

Command	Ce qu'elle fait	Quand l'utiliser
`/explain`	Explique le code sélectionné	Lire du code inconnu
`/fix`	Corrige les erreurs dans le code sélectionné	Quand il y a un bug ou une erreur
`/doc`	Génère de la documentation	Ajouter des JSDoc/docstrings
`/test`	Génère des tests unitaires	Écrire la couverture de tests
`/refactor`	Suggère du refactoring	Améliorer la structure du code
`/commit`	Génère un message de commit	Avant de committer les changements

info

Les Commands peuvent être combinées. Vous pouvez sélectionner du code, taper /doc, puis faire un suivi avec /test pour générer à la fois la documentation et les tests pour la même fonction.

Utilisez les Skills quand

Les Skills ne sont pas quelque chose que vous "utilisez" directement -- c'est quelque chose que l'IA mobilise. Mais vous pouvez activer ou configurer des skills via des serveurs MCP et le contexte du projet.

Bons configurations de skills :

Ajouter un serveur MCP pour la conscience du schéma de base de données
Activer la capacité de recherche web
Se connecter aux APIs de documentation
Configurer des connaissances spécifiques au repository

Configuration de serveur MCP (amélioration des skills)
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

Quand ces serveurs MCP sont connectés, l'IA acquiert le "skill" d'interroger votre base de données ou les issues GitHub directement.

Les combiner : Un exemple pratique

Le vrai pouvoir vient de l'utilisation des trois ensemble. Voici à quoi ressemble un workflow réel :

Scénario : Ajouter un nouveau endpoint API

Configuration (Rules) :

Votre fichier .cursorrules contient :

Stack technique : Next.js 14 App Router, TypeScript, Prisma, Zod
Conventions API :
- Toutes les routes dans app/api/[resource]/route.ts
- Utiliser Zod pour la validation des entrées
- Retourner un format d'erreur cohérent : { error: string, code: string }
- Utiliser les transactions Prisma pour les opérations multi-tables

Exécution (Commands) :

Vous sélectionnez un fichier de route existant et tapez :

/test

L'IA génère des tests pour la route existante basée sur vos rules.

Puis vous tapez :

Créez un nouveau endpoint POST pour /api/orders qui accepte
{ items: Array<{ productId: string, quantity: number }>,
  customerEmail: string } et crée une commande avec
les éléments de commande dans une transaction.

Assistance IA (Skills) :

L'IA automatiquement :

Applique vos Rules -- place le fichier dans app/api/orders/route.ts, utilise la validation Zod, enveloppe dans une transaction Prisma
Utilise son Skill pour les conventions de routage Next.js App Router
Utilise son Skill pour la syntaxe des transactions Prisma
Génère le code suivant toutes les contraintes

Code généré suivant les rules et skills
import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';
import { prisma } from '@/lib/db';

const orderSchema = z.object({
  items: z.array(z.object({
    productId: z.string().uuid(),
    quantity: z.number().int().positive()
  })).min(1),
  customerEmail: z.string().email()
});

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validated = orderSchema.parse(body);
    
    const order = await prisma.$transaction(async (tx) => {
      const newOrder = await tx.order.create({
        data: {
          customerEmail: validated.customerEmail,
          status: 'PENDING'
        }
      });
      
      await tx.orderItem.createMany({
        data: validated.items.map(item => ({
          orderId: newOrder.id,
          productId: item.productId,
          quantity: item.quantity
        }))
      });
      
      return newOrder;
    });
    
    return NextResponse.json(order, { status: 201 });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Entrée invalide', code: 'VALIDATION_ERROR' },
        { status: 400 }
      );
    }
    
    return NextResponse.json(
      { error: 'Erreur serveur interne', code: 'INTERNAL_ERROR' },
      { status: 500 }
    );
  }
}

Remarquez comment le code suit chaque rule que vous avez définie, sans que vous ayez à les répéter dans le prompt. C'est le pouvoir de combiner les trois mécanismes.

Confusions courantes et clarifications

"Puis-je transformer les Rules en Commands ?"

Pas directement. Les Rules sont des contraintes passives ; les Commands sont des actions actives. Cependant, vous pouvez écrire des commands personnalisées qui référencent vos rules :

Idée de command personnalisée

"/lint" -- une command personnalisée qui demande à l'IA de vérifier
si le code sélectionné suit toutes les rules du projet

"Les Skills remplacent-elles les Rules ?"

Non. Les Rules ont toujours la priorité. Si un skill suggère une approche qui viole une rule, l'IA devrait suivre la rule. Si vous voyez l'IA ignorer les rules, vos rules peuvent être trop vagues ou contradictoires.

"Lequel devrais-je configurer en premier ?"

Rules d'abord -- définissez vos conventions de projet
Commands ensuite -- apprenez les commandes intégrées, ajoutez des commandes personnalisées selon les besoins
Skills en dernier -- ajoutez des serveurs MCP ou du contexte une fois que vous savez quelles lacunes existent

"Puis-je en utiliser plusieurs à la fois ?"

Absolument. En fait, vous devriez. Les Rules établissent la baseline, les Commands déclenchent des actions, et les Skills comblent les lacunes de connaissances. Ils sont conçus pour travailler ensemble.

Commands personnalisées : Aller plus loin

Vous pouvez définir des commands personnalisées dans les paramètres de Cursor pour des workflows spécifiques à votre projet.

Commands personnalisées dans les paramètres
{
  "cursor.customCommands": [
    {
      "name": "api-check",
      "description": "Vérifier si une route API suit les conventions du projet",
      "prompt": "Révisez ce fichier de route API et vérifiez : 1) Est-il au bon emplacement ? 2) Utilise-t-il la validation Zod ? 3) Utilise-t-il les transactions Prisma pour les opérations multi-tables ? 4) Retourne-t-il le format d'erreur standard ? Listez toute violation."
    },
    {
      "name": "add-logging",
      "description": "Ajouter du logging structuré à une fonction",
      "prompt": "Ajoutez du logging structuré à cette fonction en utilisant le logger du projet depuis @/lib/logger. Loguez les paramètres d'entrée, les résultats de sortie et toute erreur attrapée."
    }
  ]
}

Utilisez-les en tapant /api-check ou /add-logging dans le chat.

Résumé

Fonctionnalité	Pensez-y comme	Votre action	Action de l'IA
Rules	Constitution du projet	Écrivez-les une fois	Suit automatiquement
Commands	Outils électriques	Invoquez quand nécessaire	Exécute une tâche spécifique
Skills	Expertise de domaine	Configurez/renforcez	Applique quand pertinent

Le modèle mental le plus simple :

Rules = "Faites toujours comme ça"
Commands = "Faites cette chose spécifique maintenant"
Skills = "Je sais comment faire ce genre de chose"

Configurez d'abord vos rules pour que l'IA connaisse vos standards. Apprenez les commands intégrées pour accélérer les tâches courantes. Ajoutez des skills via des serveurs MCP quand vous avez besoin que l'IA comprenne des systèmes externes. Utilisés ensemble, ils rendent Cursor significativement plus puissant que n'importe quelle fonctionnalité seule.

Définitions​

Que sont les Rules ?​

Que sont les Commands ?​

Que sont les Skills ?​

Comparaison côte à côte​

Quand utiliser chacun​

Utilisez les Rules quand​

Utilisez les Commands quand​

Utilisez les Skills quand​

Les combiner : Un exemple pratique​

Scénario : Ajouter un nouveau endpoint API​

Confusions courantes et clarifications​

"Puis-je transformer les Rules en Commands ?"​

"Les Skills remplacent-elles les Rules ?"​

"Lequel devrais-je configurer en premier ?"​

"Puis-je en utiliser plusieurs à la fois ?"​

Commands personnalisées : Aller plus loin​

Résumé​