Pular para o conteúdo principal

Modo Agent e YOLO no Cursor: Um Guia Prático

O modo Agent é provavelmente o recurso mais poderoso do Cursor, mas muita gente ainda tem medo de usá-lo direito. Ficam no chat normal, pedem trechos de código e colam manualmente nos arquivos. Isso funciona, mas você está deixando talvez 80% do potencial do Cursor na mesa.

Este guia é baseado em fluxos de trabalho reais compartilhados no fórum do Cursor. Sem teorias demais -- só coisas práticas que realmente funcionam.

Painel do modo Agent no Cursor

Modo Agent vs Chat Normal: Qual É a Diferença de Verdade​

Aqui está o que a maioria dos iniciantes não percebe: modo Agent e chat normal são completamente diferentes.

RecursoChat NormalModo Agent
Lê sua base de códigoSimSim
Sugere mudanças de códigoSimSim
Executa comandos no terminalNãoSim
Cria/modifica arquivosNãoSim
Busca entre arquivosNãoSim
Tarefas de múltiplos passosNãoSim
Requer confirmaçãoN/ASim (a menos que YOLO)

O chat normal é como ter um colega inteligente para perguntar. O modo Agent é como ter um dev júnior que realmente faz coisas -- executa comandos, cria arquivos, edita código em todo o projeto.

Quando você muda para o modo Agent (o ícone de robô no painel de chat), o Cursor ganha acesso a ferramentas: leitura/escrita de arquivos, comandos de terminal, busca de código e mais. Ele pode planejar uma abordagem de múltiplos passos e executá-la.

Quando Usar o Modo Agent

Qualquer tarefa que exija mais do que apenas "me mostre o código". Se você se pega copiando código do chat e colando em arquivos, deveria estar usando o modo Agent em vez disso.

Modo YOLO: O Que É e Quando Usar​

YOLO significa "You Only Live Once". No Cursor, o modo YOLO significa que o Agent pula todos os diálogos de confirmação e simplesmente... faz.

Alternância do modo YOLO

Sem popup "Permitir escrita de arquivo?". Sem prompt "Executar este comando?". O Agent executa de forma autônoma até a tarefa estar concluída ou ele bater em uma parede.

Quando o YOLO Faz Sentido​

  • Estruturar um novo projeto -- criar diretórios, instalar pacotes, gerar boilerplate
  • Refatoração em lote -- renomear variáveis em 50 arquivos, atualizar caminhos de import
  • Tarefas automatizadas -- gerar arquivos de teste, criar scripts de migração, escrever documentação
  • Trabalho descartável -- qualquer coisa que você possa dar git reset se der errado

Quando Manter o YOLO Desligado​

Nunca use o modo YOLO em branches de produção

Sério. Um rm -rf ruim ou uma migração de banco quebrada e você vai entender por que os diálogos de confirmação existem.

  • Código em produção ou branch main -- sempre revise mudanças aqui
  • Operações de banco de dados -- migrações, mudanças de schema, dados de seed
  • Configuração de CI/CD -- uma linha errada pode quebrar seu pipeline
  • Qualquer coisa irreversível -- se você não pode desfazer, não faça no YOLO

Como Ativar/Desativar o Modo YOLO​

  1. Abra o painel de chat do Agent (Cmd/Ctrl + Shift + A)
  2. Procure pelo toggle YOLO no topo do painel
  3. Clique para ativar/desativar

O toggle mostra um pequeno ícone de aviso quando o YOLO está ativo. Preste atenção nele.

Fluxo de Trabalho Real 1: Construindo um Novo Projeto do Zero​

É aqui que o modo Agent mais brilha. Em vez de rodar manualmente create-react-app, configurar estruturas de pastas e escrever boilerplate -- deixe o Agent cuidar de tudo.

Passo 1: Abra o modo Agent em um diretório vazio.

Passo 2: Dê um prompt claro e detalhado:

Create a Next.js 14 project with the following structure:
- App router with TypeScript
- Tailwind CSS for styling
- Authentication pages (login, register)
- A dashboard layout with sidebar navigation
- API routes for user management
- ESLint and Prettier configured
- Environment variables for database connection

Use PostgreSQL with Prisma ORM. Set up the basic schema for users with email, password hash, and timestamps.

Passo 3: Veja ele trabalhar. O Agent vai:

  1. Criar o projeto com npx create-next-app
  2. Instalar dependências (Prisma, Tailwind, etc.)
  3. Gerar a estrutura de pastas
  4. Escrever arquivos de configuração iniciais
  5. Configurar o schema do Prisma e rodar a migração inicial
  6. Criar componentes de página e rotas de API

Passo 4: Revise a saída. Mesmo no modo Agent, você deve dar uma olhada no que foi criado antes de continuar.

Dica pro do fórum

"Sempre faça commit do scaffold inicial antes de fazer mudanças. Se o Agent sair do trilho, você pode dar git checkout . e recomeçar do zero." -- @devops_mike no Fórum do Cursor

Fluxo de Trabalho Real 2: Revisão de Código Automatizada​

Você não precisa de uma ferramenta separada de revisão de código. O modo Agent pode auditar seu código para problemas comuns.

Prompt de exemplo:

Review the src/api/ directory for:
1. Security vulnerabilities (SQL injection, XSS, missing auth checks)
2. Error handling gaps (unhandled promises, missing try-catch)
3. Performance issues (N+1 queries, missing indexes)
4. Code quality (unused imports, duplicated logic, inconsistent naming)

For each issue found, explain the problem and suggest a fix. Don't apply changes yet -- just report.

O Agent vai buscar nos seus arquivos, analisar o código e te dar um relatório estruturado. Você pode então decidir quais correções aplicar.

Indo Mais Fundo​

Depois da revisão, você pode pedir ao Agent para corrigir problemas específicos:

Fix the SQL injection vulnerabilities you found. Apply the parameterized query pattern to all database calls in src/api/users.ts and src/api/orders.ts.

Esta abordagem de dois passos (revisar primeiro, corrigir depois) te dá controle enquanto ainda aproveita a velocidade do Agent.

Fluxo de Trabalho Real 3: Refatoração em Lote com .cursorrules​

Este é o combo poderoso que os usuários do fórum adoram: modo YOLO + .cursorrules.

A ideia é simples -- seu arquivo .cursorrules diz ao Agent exatamente como seu projeto funciona, então quando você pede uma grande refatoração, ele segue suas convenções em vez de inventar as próprias.

Configurando Suas Regras​

Crie um arquivo .cursorrules na raiz do projeto:

## Project Conventions
- Use TypeScript strict mode
- All API responses follow the format: { success: boolean, data: T, error?: string }
- Components use named exports, not default exports
- State management uses Zustand stores in src/stores/
- All async functions must have proper error handling with try-catch
- Use the repository pattern for database operations
- Test files go in __tests__/ directories next to source files

Executando a Refatoração​

Com o modo YOLO ligado e boas regras em vigor:

Refactor all API routes to use the repository pattern:
1. Create src/repositories/ directory
2. Extract database operations from src/api/ into repository classes
3. Update API routes to use the repositories
4. Add proper TypeScript interfaces for all repository methods
5. Create corresponding test files
YOLO + Refatoração = Sempre Git Primeiro

Antes de qualquer refatoração em lote com modo YOLO:

  1. Faça commit de todas as mudanças atuais
  2. Crie uma branch de feature
  3. Execute a refatoração
  4. Revise o diff com git diff
  5. Só faça merge se tudo estiver certo

Segurança em Primeiro Lugar: Como Não Queimar Seu Projeto​

O fórum do Cursor está cheio de histórias de terror. Aqui está como evitar virar uma delas.

Use o Shadow Workspace​

O recurso Shadow Workspace do Cursor permite que o Agent trabalhe em uma cópia do seu código. Se der errado, seus arquivos reais ficam intactos.

  1. Abra Configurações
  2. Navegue até Recursos
  3. Ative o Shadow Workspace
  4. O Agent agora trabalha em um ambiente isolado

Git É Sua Rede de Segurança​

Isso deveria ser óbvio, mas baseado nos posts do fórum, não é:

# Antes de qualquer tarefa do Agent em código importante
git add .
git commit -m "checkpoint before agent refactoring"

# Se o Agent estragar tudo
git diff            # veja o que mudou
git checkout .      # reverte tudo
# ou
git reset --hard    # opção nuclear

A Estratégia de Branches​

main (produção)     -- NUNCA execute Agent/YOLO aqui
  └── develop         -- Modo Agent OK, YOLO desligado
       └── feature/*  -- Agent + YOLO, pode soltar

Quanto mais longe da produção, mais liberdade você dá ao Agent. Branches de feature são o playground. Branch main é proibida para YOLO.

Regra de Ouro

Se você não pode perder, não deixe o Agent tocar sem um backup.

Agente em Segundo Plano: Deixe a IA Trabalhar Enquanto Você Faz Outra Coisa​

O Agente em Segundo Plano (introduzido no Cursor 0.50) é um divisor de águas para tarefas maiores. Em vez de ficar vendo o Agent trabalhar passo a passo, você delega a tarefa e continua programando outra coisa.

Como Funciona​

  1. Pressione Cmd/Ctrl + E para abrir o painel do Agente em Segundo Plano
  2. Descreva sua tarefa em detalhes
  3. Clique em "Iniciar Agent"
  4. Volte ao seu editor e trabalhe em outra coisa
  5. Verifique o painel do Agente em Segundo Plano quando terminar

Boas Tarefas para o Agente em Segundo Plano​

  • "Escreva testes unitários para todos os componentes em src/components/"
  • "Gere documentação de API para cada endpoint em src/api/"
  • "Crie um script de migração para mudar de REST para GraphQL"
  • "Refatore o módulo de autenticação para usar JWT em vez de sessões"

Coisas para Saber​

  • Agentes em Segundo Plano trabalham em um ambiente na nuvem, então não bloqueiam sua máquina local
  • Você pode rodar múltiplos Agentes em Segundo Plano simultaneamente
  • Os resultos são sincronizados de volta para seu projeto local quando o Agent termina
  • A partir do Cursor 1.1, você pode receber atualizações do Agente em Segundo Plano no Slack
Dica do Fórum

"Eu delego a escrita de testes para o Agente em Segundo Plano toda manhã enquanto trabalho em features. Na hora do almoço, tenho uma suíte de testes completa para revisar." -- @testing_alex no Fórum do Cursor

Referência Rápida: Atalhos do Modo Agent​

AçãoAtalho
Abrir chat do AgentCmd/Ctrl + Shift + A
Abrir Agente em Segundo PlanoCmd/Ctrl + E
Alternar modo YOLOClique no toggle YOLO no painel do Agent
Aceitar mudança do AgentCmd/Ctrl + Y
Rejeitar mudança do AgentCmd/Ctrl + N
Abrir ComposerCmd/Ctrl + I

Erros Comuns a Evitar​

1. Prompts Vagos​

Ruim: "Conserte meu código" Bom: "Conserte os erros de TypeScript em src/utils/parser.ts. A função de parsing de datas não lida corretamente com offsets de timezone."

2. Muitas Tarefas de Uma Vez​

O modo Agent funciona melhor com tarefas focadas e de propósito único. Em vez de "refatore tudo e adicione testes e atualize docs", divida em três sessões do Agent separadas.

3. Não Fornecer Contexto​

O Agent não sabe a história do seu projeto. Diga qual framework você está usando, quais convenções segue e o que o código deveria fazer.

4. Ignorar a Saída​

Mesmo quando o modo YOLO está ligado, você deve revisar o que o Agent fez. Um git diff rápido depois de cada sessão do Agent pega problemas antes que eles se acumulem.

Concluindo​

O modo Agent e o modo YOLO são multiplicadores de força quando usados corretamente. A chave é entender quando deixar o Agent correr solto e quando mantê-lo na coleira.

Comece pequeno. Use o modo Agent para uma tarefa de arquivo único. Depois tente uma refatoração em múltiplos arquivos. Eventualmente, você vai desenvolver uma intuição para quando o YOLO é seguro e quando não é. Essa intuição vale mais do que qualquer tutorial.

Fontes e leituras adicionais: