Cursor Skills, Commands, Rules: Qual a Diferença?

O Cursor tem três recursos que se sobrepõem mas são distintos, confundindo muitos usuários: Skills, Commands e Rules. Uma thread do fórum com 11 respostas fez essencialmente a mesma pergunta de formas diferentes — "o que cada um faz?" Este guia traça limites claros entre eles e mostra quando usar cada um.

Definições

Vamos começar com o que cada recurso realmente é.

O que são Rules?

Rules dizem à IA do Cursor como se comportar quando gera ou modifica código. Elas definem padrões de codificação, convenções, restrições e preferências.

Rules são declarativas — você declara o que deve ser verdade e a IA segue.

Exemplo de regra
Sempre use TypeScript strict mode.
Prefira named exports em vez de default exports.
Use componentes funcionais e hooks, nunca componentes de classe.

Rules se aplicam automaticamente a todas as interações de IA no projeto configurado. Você não precisa chamá-las manualmente.

Onde as Rules vivem:

Rules globais: Configurações > Geral > Rules para IA
Rules de projeto: Arquivo .cursorrules na raiz do projeto
Rules com escopo: Arquivos .mdc no diretório .cursor/rules/

O que são Commands?

Commands são prompts pré-definidos que você invoca manualmente para executar tarefas específicas. São atalhos para tarefas comuns.

Commands são imperativos — você dispara uma ação específica agora.

Exemplo de invocação de comando
Entrada: "/explain"
Resultado: IA explica o código selecionado

Entrada:
"/fix"
Resultado: IA corrige erros no código selecionado

Commands são ações explícitas do usuário. A IA não os usa a menos que você diga.

Onde os Commands vivem:

Commands embutidos: /explain, /fix, /doc, /test, etc.
Commands customizados: definidos pelo usuário nas configurações

O que são Skills?

Skills são capacidades de contexto que a IA do Cursor pode aproveitar quando necessário. Representam conhecimento de domínio ou expertise especializada que a IA pode aplicar a uma solicitação.

Skills são adaptativas — a IA decide quando usar com base no prompt.

Exemplo real de Skill
Usuário: "Configure um projeto Next.js com TypeScript, Tailwind e Prisma"

A IA usa a Skill "scaffolding de projetos Next.js" para:
- Executar os comandos de inicialização corretos
- Configurar Tailwind corretamente
- Configurar Prisma na localização correta do schema
- Configurar paths TypeScript

Você não invoca Skills explicitamente. A IA reconhece quando uma Skill se aplica e a usa automaticamente.

De onde vêm as Skills:

Embutidas no treinamento da IA do Cursor
Aprendidas do seu codebase ao longo do tempo
Adicionadas via servidores MCP (Model Context Protocol)

Comparação lado a lado

Aspecto	Rules	Commands	Skills
Propósito	Definir padrões de comportamento	Executar tarefas específicas	Aplicar conhecimento de domínio
Quando se aplica	Automático, sempre	Quando invocado manualmente	Quando a IA detecta relevância
Controle do usuário	Configure uma vez, sempre aplica	Dispare quando necessário	Implícito, a IA decide
Formato	Texto / JSON / .mdc	Comandos slash (`/fix`)	Capacidades internas da IA
Escopo	Global ou por projeto	Universal	Dependente de contexto
Exemplo	"Use ponto e vírgula"	`/explain selection`	"Sabe como fazer scaffold de apps React"

Quando usar cada um

Use Rules quando

Quer mudar consistentemente como a IA escreve código em todo o projeto.

Bons casos de uso para Rules:

Impondo estilo de código (tabs vs espaços, convenções de nomenclatura)
Especificando preferências de stack tecnológica (React vs Vue, Prisma vs Drizzle)
Definindo restrições de arquitetura (sem imports circulares, estrutura de pastas específica)
Configurando estilo de resposta ("seja conciso", "sempre adicione comentários")

Exemplo de .cursorrules
{
  "techStack": ["Next.js 14", "TypeScript", "Tailwind CSS"],
  "rules": [
    "Use Server Components por padrão",
    "Adicione 'use client' apenas quando necessário para interatividade",
    "Todas as rotas de API ficam em app/api/",
    "Use Prisma para todas as operações de banco de dados"
  ]
}

dica

As Rules são a "constituição" do seu projeto. Escreva uma vez e ela guia todas as interações de IA.

Use Commands quando

Quer executar uma tarefa específica no código selecionado ou no contexto atual agora.

Bons casos de uso para Commands:

Explicar código desconhecido (/explain)
Corrigir erros específicos (/fix)
Gerar documentação (/doc)
Escrever testes para uma função (/test)
Refatorar um bloco selecionado (/refactor)

Fluxo de trabalho com Commands
Selecione a função que quer documentar
Digite /doc no chat
A IA gera comentários JSDoc para aquela função

Referência de comandos embutidos:

Comando	O que faz	Quando usar
`/explain`	Explica código selecionado	Lendo código desconhecido
`/fix`	Corrige erros no código selecionado	Quando há bugs ou erros
`/doc`	Gera documentação	Adicionando JSDoc/docstrings
`/test`	Gera testes unitários	Escrevendo cobertura de testes
`/refactor`	Sugere refatoração	Melhorando estrutura de código
`/commit`	Gera mensagem de commit	Antes de commitar mudanças

info

Commands podem ser combinados. Você pode selecionar código, digitar /doc, e depois fazer follow-up com /test para gerar tanto documentação quanto testes para a mesma função.

Use Skills quando

Skills não são algo que você "usa" diretamente — são algo que a IA aproveita. Mas você pode ativar ou configurar Skills via servidores MCP e contexto de projeto.

Boa configuração de Skills:

Adicionar servidores MCP para reconhecimento de schema de banco de dados
Habilitar capacidade de busca na web
Conectar APIs de documentação
Configurar conhecimento específico do repositório

Configuração de servidores MCP (aprimora Skills)
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

Com esses servidores MCP conectados, a IA ganha a "Skill" de consultar seu banco de dados diretamente ou acessar issues do GitHub.

Combinando: exemplo do mundo real

O verdadeiro poder vem ao usar os três juntos. Aqui está um fluxo de trabalho real:

Cenário: adicionar um novo endpoint de API

Setup (Rules):

Seu arquivo .cursorrules contém:

Stack: Next.js 14 App Router, TypeScript, Prisma, Zod
Regras de API:
- Todas as rotas ficam em app/api/[resource]/route.ts
- Use Zod para validação de entrada
- Retorne formato de erro consistente: { error: string, code: string }
- Use transações Prisma para operações multi-tabela

Execução (Commands):

Selecione um arquivo de rota existente e digite:

/test

A IA gera testes para a rota existente baseada nas Rules.

Depois digite:

Crie um novo endpoint POST para /api/orders que aceite
{ items: Array<{ productId: string, quantity: number }>, 
  customerEmail: string } e crie pedidos e itens de pedido
em uma transação.

Suporte da IA (Skills):

A IA automaticamente:

Aplica as Rules — coloca o arquivo em app/api/orders/route.ts, usa validação Zod, envolve em transação Prisma
Usa a Skill de regras de roteamento do Next.js App Router
Usa a Skill de sintaxe de transações Prisma
Gera código que segue todas as restrições

Código gerado seguindo Rules e 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: 'Invalid input', code: 'VALIDATION_ERROR' },
        { status: 400 }
      );
    }
    
    return NextResponse.json(
      { error: 'Internal server error', code: 'INTERNAL_ERROR' },
      { status: 500 }
    );
  }
}

Note como o código segue todas as regras definidas. Você não precisou repetir isso no prompt. Esse é o poder de combinar os três mecanismos.

Confusões comuns e esclarecimentos

"Posso converter Rules em Commands?"

Não diretamente. Rules são restrições passivas. Commands são ações ativas. Mas você pode escrever Commands customizados que referenciam Rules:

Ideia de comando customizado

"/lint" -- um comando customizado que pede à IA para verificar
se o código selecionado segue todas as regras do projeto

"Skills sobrescrevem Rules?"

Não. Rules sempre têm prioridade. Se uma Skill sugerir uma abordagem que viola uma Rule, a IA deve seguir a Rule. Se você vir a IA ignorando Rules, elas podem ser muito vagas ou conflitantes.

"Qual devo configurar primeiro?"

Rules primeiro — defina as regras do projeto
Commands segundo — aprenda os embutidos, adicione customizados conforme necessário
Skills por último — adicione servidores MCP ou contexto quando souber quais lacunas existem

"Posso usar múltiplos ao mesmo tempo?"

Claro. E você deve. Rules definem a linha de base, Commands disparam ações, e Skills preenchem lacunas de conhecimento. Eles foram projetados para trabalhar juntos.

Commands customizados: indo além

Você pode definir Commands customizados nas configurações do Cursor para fluxos de trabalho específicos do projeto.

Commands customizados nas configurações
{
  "cursor.customCommands": [
    {
      "name": "api-check",
      "description": "Verifica se rotas de API seguem regras do projeto",
      "prompt": "Revise este arquivo de rota de API e verifique: 1) Está na localização correta? 2) Usa validação Zod? 3) Usa transações Prisma para operações multi-tabela? 4) Retorna formato de erro padrão? Liste violações."
    },
    {
      "name": "add-logging",
      "description": "Adiciona logging estruturado a funções",
      "prompt": "Adicione logging estruturado a esta função usando o logger do projeto em @/lib/logger. Logue parâmetros de entrada, resultado de saída, e erros capturados."
    }
  ]
}

Use-os digitando /api-check ou /add-logging no chat.

Resumo

Recurso	Pense como	Ação do usuário	Ação da IA
Rules	Constituição do projeto	Escreva uma vez	Segue automaticamente
Commands	Ferramentas de poder	Invoque quando necessário	Executa tarefa específica
Skills	Expertise de domínio	Configure/aprimore	Aplica quando relevante

Modelo mental mais simples:

Rules = "Sempre faça assim"
Commands = "Faça esta coisa específica agora"
Skills = "Sei como fazer este tipo de coisa"

Configure Rules primeiro para que a IA conheça seus padrões. Aprenda os Commands embutidos para acelerar tarefas comuns. Adicione Skills via servidores MCP quando a IA precisar entender sistemas externos. Usados juntos, são muito mais poderosos que qualquer um sozinho.

Definições​

O que são Rules?​

O que são Commands?​

O que são Skills?​

Comparação lado a lado​

Quando usar cada um​

Use Rules quando​

Use Commands quando​

Use Skills quando​

Combinando: exemplo do mundo real​

Cenário: adicionar um novo endpoint de API​

Confusões comuns e esclarecimentos​

"Posso converter Rules em Commands?"​

"Skills sobrescrevem Rules?"​

"Qual devo configurar primeiro?"​

"Posso usar múltiplos ao mesmo tempo?"​

Commands customizados: indo além​

Resumo​