Skip to main content

Cursor Rules

Rules são instruções persistentes que personalizam o comportamento do Agent. Elas garantem consistência, padronização e permitem que o Cursor entenda profundamente seu projeto e padrões.

O que são Rules?​

Rules são instruções de nível de sistema que:

  • São persistentes: Aplicadas automaticamente em conversas
  • São reutilizáveis: Compartilhadas entre membros do time
  • São contextuais: Podem ser aplicadas baseadas em arquivos ou padrões
  • São versionáveis: Armazenadas em .cursor/rules e versionadas com Git

Diferente de prompts em uma conversa, Rules fornecem contexto persistente que o Agent sempre considera.

Tipos de Rules​

1. Project Rules​

Armazenadas em .cursor/rules/, versionadas e escopadas ao codebase.

Ideal para:

  • Conhecimento específico do domínio
  • Padrões de arquitetura
  • Workflows automatizados
  • Templates e convenções

2. User Rules​

Regras globais no seu ambiente Cursor.

Ideal para:

  • Estilo de comunicação preferido
  • Convenções de código pessoais
  • Preferências de desenvolvimento

3. Team Rules​

Gerenciadas no dashboard do Cursor (planos Team e Enterprise).

Ideal para:

  • Padrões organizacionais
  • Compliance e segurança
  • Boas práticas da empresa
  • Enforçamento obrigatório

4. AGENTS.md​

Arquivo simples de markdown na raiz do projeto.

Ideal para:

  • Casos de uso simples
  • Instruções diretas
  • Projetos menores

Estrutura de uma Rule​

Cada Rule é uma pasta contendo RULE.md:

.cursor/rules/
  my-rule/
    RULE.md           # Arquivo principal
    scripts/          # Scripts auxiliares (opcional)

Formato do RULE.md​

---
description: "Esta regra define padrões para componentes frontend"
alwaysApply: false
globs: ["**/*.tsx", "**/*.ts"]
---

# Minha Rule

Quando trabalhar em componentes:
- Sempre use TypeScript
- Prefira componentes funcionais
- Use Tailwind para estilização
- Siga o padrão de nomenclatura do projeto

@component-template.tsx

Tipos de Aplicação​

Always Apply​

Aplicada em toda conversa. Use para regras fundamentais.

---
alwaysApply: true
---

- Sempre use TypeScript
- Siga os padrões de código do projeto
- Valide código antes de commit

Apply Intelligently​

O Agent decide quando aplicar baseado na descrição.

---
description: "Padrões para componentes React"
alwaysApply: false
---

Quando criar componentes React:
- Use functional components
- Prefira hooks sobre classes
- Mantenha componentes pequenos

Apply to Specific Files​

Aplicada quando arquivos correspondem ao padrão.

---
globs: ["**/*.test.ts", "**/*.spec.ts"]
---

Para arquivos de teste:
- Use Jest como framework
- Siga padrão AAA (Arrange, Act, Assert)
- Mantenha testes isolados

Apply Manually​

Aplicada quando mencionada com @ no chat.

---
description: "Template para criar novos serviços"
alwaysApply: false
---

@my-rule Crie um novo serviço seguindo este template

Exemplos Práticos​

Rule para Padrões de API​

---
description: "Padrões para criação de endpoints de API"
globs: ["**/api/**/*.ts", "**/routes/**/*.ts"]
---

# API Standards

Ao criar endpoints:
- Use validação com Zod
- Retorne status codes apropriados
- Inclua tratamento de erros
- Documente com JSDoc
- Adicione testes unitários

Estrutura esperada:
```typescript
import { z } from 'zod';

const schema = z.object({
  // schema aqui
});

export async function handler(req: Request) {
  // validação
  // lógica
  // resposta
}

@api-template.ts


### Rule para Componentes React

```markdown
---
description: "Estrutura padrão para componentes React"
globs: ["**/*.tsx"]
---

# React Component Standards

Componentes devem:
- Ser funcionais
- Usar TypeScript
- Ter props tipadas
- Seguir naming: PascalCase
- Estar em arquivos separados

Estrutura:
```tsx
interface Props {
  // props aqui
}

export function ComponentName({ prop }: Props) {
  // implementação
}

### Rule para Workflows

```markdown
---
description: "Workflow para análise de aplicação"
alwaysApply: false
---

Quando pedir para analisar a aplicação:
1. Execute `npm run dev`
2. Capture logs do console
3. Analise performance
4. Sugira melhorias priorizadas
5. Gere relatório estruturado

Best Practices​

✅ DO​

  • Seja específico: Instruções claras e concretas
  • Use exemplos: Referencie arquivos com @filename
  • Mantenha focado: Rules menores e específicas
  • Documente: Explique o "porquê" das regras
  • Version controle: Mantenha Rules no Git

❌ DON'T​

  • Não seja vago: Evite "seja consistente"
  • Não exagere: Rules muito longas são menos efetivas
  • Não duplique: Reutilize Rules quando possível
  • Não ignore contexto: Rules devem fazer sentido para o projeto

Benefícios​

Consistência​

  • Todo o time segue os mesmos padrões
  • Código mais uniforme e manutenível
  • Menos debates sobre estilo

Produtividade​

  • Menos tempo explicando padrões
  • Agent já conhece as regras
  • Menos erros de convenção

Onboarding​

  • Novos membros aprendem rapidamente
  • Documentação viva e atualizada
  • Menos perguntas sobre "como fazer"

Qualidade​

  • Padrões aplicados automaticamente
  • Menos code review sobre estilo
  • Foco em lógica e arquitetura

Integração com Agents​

Rules funcionam perfeitamente com Agents:

  1. Rules definem padrões do projeto
  2. Agents seguem essas regras automaticamente
  3. Resultado: Código consistente e alinhado

Artigos Relacionados​

Para mais detalhes sobre Rules, confira:

Conclusão​

Rules são fundamentais para personalizar o Cursor. Elas transformam o Cursor de uma ferramenta genérica em um assistente que entende profundamente seu projeto.

No próximo capítulo, vamos explorar Commands e como criar workflows automatizados.

Próximo: Cursor Commands