Guia Definitivo: Cursor

Quando você abre o Cursor pela primeira vez, a sensação é de um VS Code que já nasceu sabendo programar. E não é coincidência — o Cursor é literalmente um fork do VS Code, mas com IA integrada em cada interação: autocompletar, edição multi-arquivo, agentes autônomos e um sistema de indexação que entende seu repositório inteiro. Com mais de um milhão de desenvolvedores pagantes e receita anualizada acima de US$ 1 bilhão, o Cursor se consolidou como a IDE de referência para quem trabalha com agentes de codificação em 2026.

Este guia cobre tudo: da instalação ao uso avançado com MCP servers, passando pelo controverso modelo de créditos e as novidades do Cursor 3.0.

Overview

O que é o Cursor

O Cursor é uma IDE standalone desenvolvida pela Anysphere, construída sobre um fork do VS Code. Isso significa que você mantém todas as extensões, keybindings e temas que já usa — mas ganha uma camada de IA profundamente integrada que vai muito além de um plugin.

Diferente do GitHub Copilot (que é uma extensão adicionada ao seu editor), o Cursor controla o ambiente inteiro. Isso permite funcionalidades que plugins simplesmente não conseguem oferecer: indexação semântica do codebase completo, edições coordenadas em múltiplos arquivos, e agentes em background que trabalham enquanto você faz outra coisa.

Posicionamento no mercado

Em maio de 2026, o Cursor está avaliado em US$ 29,3 bilhões após sua Series D e é usado por 64% das empresas Fortune 500. O cenário competitivo inclui:

• GitHub Copilot — plugin que funciona em qualquer editor, a US$ 10/mês
• Windsurf — IDE similar (também fork do VS Code), a US$ 20/mês
• Claude Code — agente de terminal da Anthropic, complementar ao Cursor
• Cline — extensão open-source para VS Code, gratuita (BYO keys)

O diferencial do Cursor é a profundidade da integração: o agente não apenas sugere código — ele lê seu repositório, executa comandos no terminal, navega na web, e itera sobre seus próprios erros.

Cursor 3.0: a era dos agentes

Em 2 de abril de 2026, o Cursor 3.0 mudou fundamentalmente o que “Cursor” significa. A nova versão introduziu a Agents Window — uma interface dedicada construída em torno de agentes, não de arquivos. O IDE tradicional ainda existe (e você pode usar ambos simultaneamente), mas a mensagem é clara: o agente é a unidade de trabalho, não o arquivo.

Novidades do 3.0:

• Agents Window — execute múltiplos agentes em paralelo (local, cloud, worktrees, SSH remoto)
• Design Mode — selecione elementos visuais no browser integrado e alimente o agente com contexto visual
• /best-of-n — rode a mesma tarefa em múltiplos modelos simultaneamente, cada um em seu worktree isolado
• /worktree — agente trabalha em checkout isolado sem tocar seu branch principal
• Cloud agents — tarefas longas rodam em VMs Ubuntu na nuvem; resultados ficam esperando quando você volta
• Composer 2 — modelo próprio do Cursor (baseado em Kimi K2.5), otimizado para coding agentic

[IMAGEM: Interface do Cursor 3.0 mostrando a Agents Window com múltiplos agentes rodando em paralelo]

Tutorial

Instalação

O Cursor está disponível para macOS, Windows e Linux. A instalação é direta:

1. Acesse cursor.com e baixe o instalador para seu sistema
2. Execute o instalador — no Linux, é um .AppImage ou .deb
3. Na primeira execução, o Cursor oferece importar suas configurações do VS Code

# Linux (Debian/Ubuntu)
sudo dpkg -i cursor_*.deb

# Ou via AppImage
chmod +x cursor-*.AppImage
./cursor-*.AppImage

Migração do VS Code

A migração é praticamente automática. Na primeira abertura, o Cursor detecta sua instalação do VS Code e oferece importar:

• Extensões — todas as extensões compatíveis com VS Code funcionam no Cursor
• Keybindings — seus atalhos personalizados são preservados
• Settings — settings.json é importado integralmente
• Temas — seu tema atual vem junto

A comunidade reporta que a migração completa leva menos de 10 minutos. Você pode manter ambos instalados sem conflito — o Cursor usa diretórios de configuração separados.

Dica: se você usa extensões que dependem de APIs específicas do VS Code (como algumas extensões de debug), teste-as após a migração. A grande maioria funciona sem problemas, mas edge cases existem.

Primeiro uso: os três modos

O Cursor opera em três modos de interação com IA, e entender quando usar cada um é a diferença entre resultados excelentes e frustrantes.

Ask Mode (Ctrl+L)

Ask é somente leitura. Ele pesquisa seu codebase, responde perguntas, explica código e elabora planos — mas nunca escreve um arquivo. Use para:

• Explorar código desconhecido: “como funciona o fluxo de autenticação neste serviço?”
• Planejar antes de implementar: “qual a melhor abordagem para adicionar rate limiting aqui?”
• Obter segunda opinião sobre design

Prompt exemplo (Ask mode):
"Analise a estrutura de rotas em src/api/ e sugira como 
organizar um novo módulo de notificações seguindo o mesmo padrão."

Agent Mode (Ctrl+I)

Agent é o modo autônomo. Você descreve uma tarefa; o Cursor lê arquivos, edita múltiplos arquivos, executa comandos no terminal, consulta a web se necessário, e itera sobre erros. É onde a mágica acontece — e também onde runs ruins saem dos trilhos.

O Agent mode recompensa tarefas bem delimitadas com critérios claros de aceitação:

✅ Bom prompt para Agent:
"Adicione um middleware de rate-limit na rota /api/ingest. 
Use express-rate-limit com limite de 100 requests/15min. 
Escreva um teste com Vitest. Rode os testes."

❌ Prompt vago:
"Melhore o código de autenticação."

Manual Edit Mode

Manual (anteriormente chamado “Composer” em versões mais antigas) é para edições cirúrgicas em múltiplos arquivos onde você quer que o modelo proponha mudanças mas não execute comandos ou saia do escopo. Ideal quando você sabe exatamente o que quer alterado.

O padrão que funciona

A sequência que consistentemente produz os melhores resultados:

1. Explore em Ask — entenda o contexto
2. Planeje em Ask — elabore a abordagem sem escrever código
3. Implemente em Agent — execute o plano com escopo definido
4. Refine em Manual — ajustes cirúrgicos no resultado

Pular o Ask é a causa mais comum de “o Cursor escreveu lixo” que desenvolvedores reportam.

[IMAGEM: Fluxo de trabalho mostrando a progressão Ask → Agent → Manual com exemplos de cada etapa]

Uso intermediário: cenário real

Vamos a um exemplo concreto — adicionar upload de arquivos com virus scanning a uma API Next.js:

Passo 1 — Ask mode:

"Onde o pipeline de upload atualmente coloca os arquivos, 
e onde geramos signed URLs?"

Passo 2 — Ainda em Ask:

"Elabore um plano para adicionar virus scanning server-side 
antes de gerar a signed URL. Não escreva código ainda."

Passo 3 — Agent mode (com o plano no contexto):

"Implemente apenas o passo 1 do plano. 
Pare após o teste unitário passar."

Passo 4 — Revise o diff linha por linha. Rejeite qualquer coisa que tocou arquivos fora do escopo planejado.

Passo 5 — Repita para os passos 2 e 3.

Configuração avançada: Cursor Rules

Rules são o maior alavanca para fazer o Cursor parar de alucinar no seu codebase. O formato legado .cursorrules na raiz do repo foi substituído por Project Rules: arquivos .mdc dentro de .cursor/rules/, versionados por projeto e com escopo por glob patterns.

Exemplo de uma rule eficaz:

<!-- .cursor/rules/api-patterns.mdc -->
---
description: Padrões para rotas de API
globs: ["src/api/**/*.ts"]
---

## Convenções de API

- Use o padrão de handler em `src/api/users/route.ts` como referência
- Sempre valide input com Zod antes de processar
- Retorne erros no formato `{ error: string, code: number }`
- Nunca delete `.env` ou `package.json` sem confirmação
- Rode `npm run typecheck && npm run test` antes de declarar concluído
- Se encontrar um problema de segurança, pare e reporte

O que boas rules incluem em 2026:

• Referências a arquivos canônicos (em vez de inlinar padrões)
• Guardrails explícitos (o que o agente NÃO deve fazer)
• Comandos de verificação (lint, typecheck, test)
• Condições de parada
• Tom e verbosidade esperados

Times que vão de “30% de sugestões aceitas” para “80%+” quase sempre fizeram o salto escrevendo rules focadas, não trocando de modelo.

Deep Dive

Modelo de créditos (desde junho 2025)

Em junho de 2025, o Cursor substituiu o modelo simples de “500 fast requests por mês” por um sistema baseado em créditos. A mudança foi controversa — a comunicação foi ruim, cobranças inesperadas apareceram, e o Cursor emitiu um pedido público de desculpas em 4 de julho de 2025, oferecendo reembolsos.

Como funciona hoje:

Cada plano pago inclui um pool de créditos igual ao valor da assinatura. Quando você usa features de IA, créditos são consumidos baseado no modelo escolhido e na complexidade da request.

O que NÃO consome créditos significativamente:

• Tab completions (autocomplete)
• Auto mode (Cursor escolhe o modelo automaticamente)

O que consome créditos rapidamente:

• Selecionar manualmente Claude Opus, GPT-5.x ou Gemini Pro
• Context windows grandes (apontar o Cursor para muitos arquivos)
• Tarefas complexas de Agent multi-arquivo
• Runs de Background Agent

O insight chave: se você ficar no Auto mode e Tab completions, o Pro é efetivamente ilimitado para a maioria dos casos. O sistema de créditos só morde quando você manualmente seleciona os modelos frontier mais caros em tarefas pesadas.

Quando seu pool se esgota, você pode pagar por uso adicional a taxas de API ou mudar para Auto mode pelo resto do mês.

Impacto prático: o mesmo Pro de US$ 20 que antes parecia “all-you-can-eat” agora visivelmente drena durante sessões pesadas com Opus. Desenvolvedores no plano Pro que rodam sessões frequentes de Agent reportam gasto real mais próximo de US$ 40-50/mês com overages.

Modelos disponíveis

O Cursor oferece acesso a modelos frontier de múltiplos providers, roteados via sua infraestrutura:

Composer 2: o modelo próprio

Lançado em 19 de março de 2026, o Composer 2 é o modelo que alimenta os agentes no novo workspace. Construído sobre uma base Kimi K2.5 da Moonshot AI, com continued pretraining e reinforcement learning 4x.

Números relevantes:

• Velocidade: 200+ tokens/segundo
• Context window: 200.000 tokens com auto-sumarização
• Custo: ~90% mais barato que Claude Opus por token
• Pricing: US$ 0,50/1M tokens input (standard) ou US$ 1,50/1M (fast)

O Composer 2 tem seu próprio pool de uso separado dos créditos para modelos frontier selecionados manualmente.

Endpoints customizados

Você pode trazer qualquer API OpenAI-compatible para dentro do Cursor: insira nome, base URL e key, e o modelo aparece no picker. Cobranças vão direto para sua conta no provider, bypassando o pool de créditos do Cursor.

Casos de uso comuns:

• Endpoint self-hosted de DeepSeek ou Llama na sua infra
• OpenRouter ou Together para modelos que o Cursor não curou
• Setup privacy-sensitive onde toda request precisa ir para seu VPC

Indexação do codebase

Quando você abre um repositório, o Cursor:

1. Chunka arquivos localmente
2. Computa uma Merkle tree de hashes
3. Sincroniza hashes com o servidor
4. Produz embeddings (armazenados no Turbopuffer, um vector DB remoto)
5. Usa os embeddings para recuperar chunks semanticamente relevantes em cada query

Re-indexar o mesmo repo é rápido porque chunks são cacheados por hash. Paths são ofuscados via encriptação por segmento — mesmo com o índice “na nuvem”, sua estrutura de pastas não fica em plaintext no servidor.

Dica crítica para monorepos: sem um .cursorignore bem configurado, indexar um monorepo de 1M+ arquivos pode saturar disk IO por 5-15 minutos. Com um, são 10-30 segundos.

# .cursorignore
node_modules/
dist/
build/
.next/
coverage/
*.generated.*

Privacy Mode

Com Privacy Mode ativado, o backend do Cursor não retém código ou dados após processar uma request. Nenhum código plaintext é persistido server-side; é buscado apenas no momento da inferência, apenas para os arquivos específicos que a request precisa, e descartado depois.

O Cursor mantém acordos de zero-data-retention com todos os model providers que roteia. Para trabalho regulado, Privacy Mode é o mínimo; Enterprise adiciona enforcement org-wide e audit logging.

Integrações

MCP Servers

Model Context Protocol (MCP) é o padrão para plugar ferramentas e fontes de dados externas em clientes de IA. O suporte do Cursor a MCP amadureceu de “brinquedo de power user” em 2024 para “feature de primeira classe com one-click install” em 2026.

Como funciona na prática:

• Três tipos de transporte: stdio (mais simples, local), SSE, e Streamable HTTP
• Dois escopos: global (Cursor Settings → Tools & MCP) ou por projeto via .cursor/mcp.json
• One-click installs do catálogo curado (GitHub, Linear, Sentry, Postgres, Notion, Stripe, etc.)
• Limite de 40 tools por sessão — exceda e o Cursor para de expor tools adicionais ao modelo

// .cursor/mcp.json (exemplo por projeto)
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "env:GITHUB_TOKEN"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "env:DATABASE_URL"
      }
    }
  }
}

Combinação que entrega mais valor:

1. GitHub — PRs, issues, code search
2. Database (Postgres ou seu warehouse) — read-only por padrão
3. Docs-search (Notion, Confluence) — documentação interna
4. Linear/Jira — tickets e contexto de produto
5. Playwright — quando o agente precisa navegar um browser

Cinco servers, bem abaixo do limite de 40 tools, e o agente para de precisar perguntar por contexto que ele pode buscar sozinho.

Extensões VS Code compatíveis

Por ser um fork do VS Code, o Cursor suporta o ecossistema inteiro de extensões. Extensões populares que funcionam sem problemas:

• Prettier, ESLint, Biome — formatação e linting
• GitLens — histórico e blame
• Docker — containers
• Prisma, Drizzle — ORMs
• Tailwind CSS IntelliSense — autocomplete de classes
• Thunder Client, REST Client — testes de API
• Language servers (Python, Go, Rust, etc.)

Exceções conhecidas: algumas extensões que dependem de APIs internas muito específicas do VS Code podem ter comportamento inesperado. Teste após migrar.

Cursor Marketplace

Além das extensões VS Code, o Cursor tem seu próprio Marketplace de plugins que adicionam capacidades ao agente:

• Skills — prompts que agentes podem invocar sob demanda
• Subagents — agentes especializados
• MCP servers — com OAuth integrado
• Hooks — automações pré/pós ação
• Rules — regras compartilháveis

Plugins disponíveis incluem: AWS, Figma, Linear, Stripe, Vercel, Datadog, Snowflake, entre outros.

[IMAGEM: Cursor Marketplace mostrando plugins disponíveis com categorias e one-click install]

Automations

Lançadas em 5 de março de 2026, Automations são agentes always-on disparados por eventos externos:

• Schedules (cron)
• Mensagens no Slack
• Issues no Linear
• Eventos no GitHub
• Incidentes no PagerDuty

O agente sobe um sandbox cloud e segue instruções usando MCPs e modelos configurados. Com memory ativada, o agente mantém notas persistentes entre runs (como um MEMORIES.md).

Planos e Preços

Billing anual economiza 20% em todos os planos pagos.

Qual plano escolher?

Comece com Hobby se nunca usou o Cursor e quer avaliar antes de migrar. Não espere usar como editor principal — você vai bater nos limites no meio de uma feature.

Vá de Pro se você programa diariamente e quer assistência de IA no workflow inteiro. A maioria dos desenvolvedores acha o Pro suficiente, a menos que rode tarefas pesadas de Agent constantemente.

Upgrade para Pro+ se seus overages no Pro regularmente excedem US$ 20-40/mês. A matemática favorece Pro+ quando você bate limites consistentemente.

Considere Ultra apenas se seus overages no Pro+ são substanciais e você trata o Cursor como infraestrutura, não como assinatura.

Escolha Teams no momento em que precisar de billing centralizado ou contexto compartilhado entre um time de desenvolvedores.

Desconto para estudantes

O Cursor oferece acesso gratuito para estudantes. Cadastre-se com email institucional e verifique na página de estudantes. Se já tiver um plano pago, o Cursor reembolsa o saldo restante automaticamente.

Avaliação: Spider Chart

Notas de 1 a 10 baseadas em benchmarks públicos + avaliação prática.

Média geral: 8.0/10

Metodologia: Código baseia-se em SWE-bench Verified, SWE-bench Multilingual e CursorBench. Autonomia em Terminal-Bench 2.0 + avaliação prática. Demais eixos são avaliação prática comparativa com concorrentes diretos (Claude Code, Copilot, Windsurf, Cline). Escala: 1-4 (fraco), 5-6 (adequado), 7-8 (bom), 9-10 (excelente/líder). Dados de maio/2026.

[IMAGEM: Spider chart radar com 8 eixos mostrando as notas do Cursor — destaque em Velocidade (9) e Contexto (9), com Custo-benefício (7) como ponto mais baixo]

Prós e Contras

Prós

• Integração profunda com o codebase — o Cursor entende seu repositório inteiro via indexação semântica, não apenas o arquivo aberto. Isso produz sugestões dramaticamente melhores que plugins que só veem o contexto local.

• Migração zero-friction do VS Code — extensões, temas, keybindings, tudo funciona. Você não perde nada da sua configuração atual.

• Multi-modelo com routing inteligente — acesso a Claude, GPT, Gemini, DeepSeek e Composer 2 no mesmo lugar. Auto mode escolhe o melhor modelo para cada tarefa sem você pensar nisso.

• Agentes paralelos (Cursor 3.0) — /best-of-n e worktrees isolados permitem rodar múltiplas abordagens simultaneamente e escolher a melhor. Game-changer para refactors complexos.

• Ecossistema MCP maduro — one-click install de dezenas de integrações. O agente busca contexto sozinho em vez de perguntar para você.

• Cloud agents — tarefas longas rodam na nuvem enquanto você fecha o laptop. Resultados com screenshots e demos esperando quando você volta.

• UX polida — a experiência de usar o Cursor é consistentemente elogiada. Diffs claros, inline suggestions suaves, chat integrado sem fricção.

Contras

• Modelo de créditos confuso — a transição de 2025 ainda gera frustração. Desenvolvedores heavy users no Pro frequentemente gastam mais que os US$ 20 esperados. Monitorar o dashboard de uso é obrigatório.

• Degradação em sessões longas — qualidade do Agent cai em sessões muito extensas. Contexto fragmenta, tool calls inflam. Reinicie a sessão em pontos naturais (por tarefa, por PR).

• Monorepos são problemáticos — sem .cursorignore bem configurado, indexação trava. Mesmo com, o agente pode sugerir imports cross-package indevidos. Codifique boundaries em Project Rules.

• Diffs grandes e difíceis de revisar — refactors multi-arquivo podem produzir PRs tecnicamente corretos mas praticamente irrevisáveis. Force o agente a trabalhar em escopos menores.

• Alucinação de APIs — mesmo modelos top inventam métodos que parecem corretos. Faça “verificar que o package e método existem antes de chamar” uma rule.

• Requer conexão com internet — o Cursor precisa de cloud inference para chat e agent. Se você precisa de inferência 100% local, considere alternativas como Void AI ou Cline com modelo local.

• Limite de 40 tools MCP — exceder silenciosamente faz o modelo perder acesso a tools posteriores. Curadoria é obrigatória.

• Vendor lock-in relativo — embora baseado em VS Code, features como rules, MCP configs e workflows são específicos do Cursor. Migrar para outro editor significa perder essa camada.

Veredicto

Ideal para: desenvolvedores que usam VS Code como editor principal e querem IA profundamente integrada no workflow diário. Times que precisam de controles enterprise (SSO, audit, privacy). Quem trabalha em projetos de médio porte com codebase bem estruturado.

NÃO ideal para: quem precisa de inferência 100% local (regulação, air-gap). Desenvolvedores em monorepos massivos sem disposição para configurar .cursorignore e rules. Quem tem orçamento apertado e usa IA intensivamente (o Pro pode não ser suficiente). Quem prefere workflow de terminal puro (considere Claude Code).

Recomendação prática: comece no Pro, monitore seu dashboard de uso no primeiro mês, e faça upgrade apenas se bater limites consistentemente. Para a maioria dos desenvolvedores, US$ 20/mês é exatamente o ponto certo.

Se você está implementando agentes de codificação no seu time e precisa de ajuda com configuração de rules, MCP servers, ou estratégia de adoção, a ft.ia.br oferece consultoria especializada para times que querem extrair o máximo dessas ferramentas.