Migrei do Cursor para o Claude Code

Não substituí o Cursor totalmente, mas agora, para features grandes e refatorações, o Claude Code é o principal.

1 ano atrás, implementar uma feature de média complexidade levava uma semana. Com Cursor e seus avanços, consegui reduzir pra 1-2 dias.

Hoje, com Claude Code, termino features grandes em uma única sessão (2-3h). A diferença? Aprendi a trabalhar com verdadeiros agentes de IA.

A mudança não foi fácil. Primeiro tive que vencer o medo de soltar o controle. Mas quando você vê um agente editando vários arquivos perfeitamente em segundos, sem esquecer nenhum import, entende que o jogo mudou.

✨ O que esperar do artigo

• Pair programming com IA — como uso o Claude Code pra descobrir desconhecidos, organizar raciocínio e criar PRDs antes de implementar

• Cinco workflows testados e aprovados que uso no dia a dia: explorar/planejar/codar, TDD com agentes, iteração visual, modo YOLO seguro e Q&A pra onboarding

• Organizando seu código em "leaf nodes" pra reduzir contexto e facilitar o trabalho do agente, com exemplos práticos de frontend e backend

📢 Mudança de preços do Dev na Gringa

Os preços do DnG vão aumentar no final desse mês.

Plano mensal: R$69,90 → R$99,90

Plano anual: R$399,90 → R$599,90

Sempre planejamos fazer essa mudança quando o portal de vagas chegasse numa versão estável. Chegou a hora.

Como nas outras mudanças:

• Os preços não mudam pra quem já é assinante

• Até o final de agosto, você pode assinar no preço atual e manter pra sempre

• Agora também aceito PIX (mas como não é recorrente, o preço não fica garantido). O pagamento é feito pelo nagringa.dev

O que é Claude Code?

Claude Code é uma ferramenta de linha de comando da Anthropic que funciona como um agente de IA puro. Diferente de extensões no VS Code ou Cursor, você roda direto no terminal e ele pode editar dezenas de arquivos simultaneamente.

Ele foi lançado em Fevereiro desse ano em research preview, e lançado oficialmente junto com o Sonnet 4 em Maio.

A diferença principal? No Cursor, mesmo no Agent mode, você supervisiona cada mudança. No Claude Code, você define o objetivo e deixa o agente trabalhar. É como ter um desenvolvedor júnior muito capaz que executa em segundos o que levaria horas.

Agentes de código são wrappers em cima de LLMs que usam um loop de várias ferramentas para executar tarefas. Fonte: Anthropic

Por que saí do Cursor (parcialmente)

Minha transição começou em junho de 2025. Testei o Claude Code em projetos pequenos, mais por curiosidade que necessidade. O Cursor já me deixava produtivo, especialmente com o Agent mode.

Em julho, decidi tentar o Claude Code pra features grandes. A primeira semana foi punk. Mesmo acostumado com agentes, o Claude Code exigia um nível de confiança que eu ainda não tinha.

O ponto de virada foi descobrir que TDD funciona perfeitamente pra programar usando agentes. Nunca fui fã de Test-Driven Development antes, mas com agentes faz todo sentido. Você define os testes primeiro, garante que falham, e depois deixa o agente implementar até passar. É uma rede de segurança que permite confiar sem precisar revisar cada linha.

Hoje uso uma divisão clara:

Cursor pra:

• Revisões rápidas e ajustes pequenos

• Quando preciso de feedback visual imediato

• Trabalho principalmente sozinho

Claude Code pra:

• Features grandes e refatorações

• Quando quero automação real (sem supervisão constante)

• Projetos em equipe (CLAUDE.md é compartilhável)

Trabalho principalmente com Python e TypeScript, duas linguagens super populares. Isso ajuda na qualidade do output porque o Claude teve muito material de treino nessas linguagens. Curiosamente, achei TypeScript mais fácil pro agente. Os tipos explícitos facilitam definir e validar o comportamento esperado.

Exemplo recente: o portal de vagas

Mês passado, lancei o Portal de Vagas do DnG. Ele veio da minha tentativa de aprender mais sobre web scraping enquanto trazia mais benefícios para a minha comunidade.

Como criei um agregador de vagas na gringa pra brasileiros

Recentemente, recebi o feedback que era difícil identificar quais vagas já apliquei / visualizei / não tenho interesse. Pois não havia um jeito fácil de fazer isso na UI.

Essa foi uma feature mais complexa que resolvi fazer exclusivamente com o Claude Code.

Antes (sem IA): Estimativa de 1-2 semanas pra tudo funcionar. Com Cursor: 1-2 dias. Com Claude Code: Uma sessão de +- 3 horas.

Meu prompt inicial:

take a look around the codebase, as I want you to help me build our a prompt for the new feature we're looking to do.                                             In our job board on @src/app/vagas/jobs-content.tsx, we currently show all jobs and track interactions when clicked. However, our customers do not know what jobs they have interacted so far.                                                So we want to be able to tell them which jobs they have seen, otherwise they might apply to the same job two times.                                           The component that displays the job is @src/app/vagas/components/job-card.tsx    This feature is also only relevant for paid subscribers, as free do not have access to most jobs anyway.                                                      I think the main files we'll be changing are probably @src/app/vagas/components/job-card.tsx and @convex/jobs.ts, but there might be more. Help me figure out all the unknowns here, then we'll work on a prompt together for a future agent. 

O que o Claude fez:

• Leu a estrutura atual do meu projeto

• Entendeu todos os desafios/edge cases que poderiam vir a surgir

• Me perguntou de outras dúvidas que eu não tinha considerado

• Me ajudou a definir as interfaces

• E compilou tudo num plano, que fizemos de maneira iterativa

Resultado: com o plano elaborado, passei ele numa nova sessão do Claude Code. Todo o código foi feito em one-shot com esse prompt elaborado. Estava tudo funcionando no que diz respeito as regras de negócio.

Implementei os testes (na verdade, o Claude Code), e com isso, ficou fácil ver que as mudanças estavam funcionando.

Fiz alguns ajustes de UI/UX depois, pois não acho que as LLMs são boas o suficientes para fazerem tudo de maneira sozinha. Embora isso está mudando.

As novas funcionalidades adicionas recentemente pelo Claude Code no nosso portal de vagas.

Pair programming com IA: meu processo pra features complexas

O que mais mudou no meu workflow foi aprender a usar o Claude Code como um par de verdade. Não é só jogar uma tarefa e esperar. É uma conversa estruturada pra descobrir o que você nem sabe que não sabe.

Quando há desconhecidos, meu primeiro trabalho é descobrir quais são. Como todo engenheiro de software, preciso mapear o território antes de construir. Abro uma sessão com o Claude Code e faço exatamente isso.

Despejo todo o contexto do trabalho: problema de negócio, arquitetura atual, restrições técnicas, aquele débito técnico que todo mundo ignora. Peço pro agente me ajudar a pensar em edge cases que não considerei, implicações pra arquitetura, possíveis pontos de falha.

Trato como uma sessão de pair programming real. Interrompo quando vejo algo estranho (Escape pra parar, duplo Escape pra voltar no histórico). Questiono decisões. Peço alternativas. É uma conversa de igual pra igual, não um monólogo.

A parte mais importante vem antes da sessão ser compactada. O contexto enche mesmo com 200k tokens. Antes disso acontecer, peço pro Claude resumir tudo num PRD (Product Requirements Document) que será usado como input pra um agente de código. Esse PRD precisa ter:

• O problema específico que estamos resolvendo

• Decisões arquiteturais que tomamos na discussão

• Edge cases identificados durante o pair

• Maneiras de verificar que funcionou (crucial!)

Por que isso importa? Porque chegamos num ponto onde você não vai conseguir revisar todas as linhas de código. Precisa ter uma maneira de validar que os resultados são os esperados sem mergulhar em cada detalhe de implementação.

Configuração inicial: CLAUDE.md e ferramentas

Antes de mergulhar nos workflows, você precisa configurar o ambiente. O arquivo CLAUDE.md é sua memória persistente - Claude não lembra de sessões anteriores, então esse arquivo carrega contexto automaticamente.

Comandos básicos que você precisa saber:

• claude - inicia sessão normal

• claude --dangerously-skip-permissions - modo YOLO (sem pedir permissão)

• Escape - interrompe Claude durante qualquer fase

• Duplo Escape - volta no histórico e edita prompt anterior

• /clear - limpa contexto quando sessão fica muito longa

• /compact - resume sessão preservando informações importantes

Dica importante: escreva prompts sempre em inglês. A maior parte do material de treino do Claude é em inglês, então você terá resultados melhores.

Exemplo de CLAUDE.md do PostHog:

# PostHog Development Guide

## Commands
- Tests: `pytest` (all) or `pytest path/to/test.py::TestClass::test_method` (single)
- Frontend tests: `pnpm --filter=@posthog/frontend test`
- Lint Python: `ruff .`
- Lint Frontend: `pnpm --filter=@posthog/frontend format`
- Start dev: `./bin/start`

## Code Style
- Python: Use type hints, follow mypy strict rules
- Frontend: TypeScript required, explicit return types
- CSS: Use tailwind utility classes instead of inline styles
- Error handling: Prefer explicit error handling with typed errors
- Naming: camelCase for JS/TS, snake_case for Python
- Comments: Explain WHY, not WHAT. Don't duplicate code.
- Tests: Prefer parameterized tests, use descriptive names

O Claude Code também suporta MCP (Model Context Protocol) pra ferramentas externas. Eu uso principalmente o Playwright MCP pra automação de browser e verificação visual. Mas pra começar, o Claude já conhece bem ferramentas padrão como git, npm, e psql.

Cinco workflows que realmente funcionam

Testei todos os workflows que a Anthropic recomenda. Aqui estão os que incorporei no meu dia a dia.

1. Explorar, planejar, codar, commitar

Esse é meu workflow padrão pra features novas. A sacada é não deixar o agente sair codando direto.

Primeiro, peço pro Claude ler os arquivos relevantes. Às vezes dou ponteiros gerais ("lê o arquivo que gerencia autenticação"), às vezes específicos ("lê auth.py"). Sempre adiciono: "não escreva código ainda, só entenda".

Depois vem a fase crucial: peço pro agente pensar. Literalmente uso a palavra "think" ou suas variações. A Anthropic mapeou diferentes níveis de "pensamento" no sistema: "think" < "think hard" < "think harder" < "ultrathink". Cada nível dá mais tempo de computação pro Claude avaliar alternativas.

Com o plano pronto, às vezes peço pro Claude criar um documento ou issue no GitHub. Isso serve como checkpoint. Se a implementação sair errada, volto pro plano sem perder o contexto.

2. TDD: testes primeiro, código depois

Meu workflow favorito quando consigo definir bem os inputs e outputs esperados.

Começo pedindo pro Claude escrever testes baseados em pares entrada/saída. Sou explícito: "estamos fazendo TDD, não crie implementações mock mesmo que a funcionalidade não exista ainda".

Rodo os testes e confirmo que falham. Commit quando estou satisfeito. Aí peço pro Claude implementar até todos os testes passarem, sem modificar os testes. Dependendo se fiz um plano anterior ou não, pode levar algumas iterações.

Eu nunca fui fã de TDD. Mas, com o Claude Code, confesso que estou usando cada vez mais.

3. Iteração visual com screenshots

Pra frontend, esse workflow é matador. Uso o Playwright MCP pra dar "olhos" pro Claude.

Dou um mock visual, peço pro Claude implementar, tirar screenshot do resultado, e iterar até ficar igual. Depois de 2-3 iterações, geralmente fica excelente.

4. Modo YOLO (mas seguro)

Às vezes você só quer que o agente resolva algo sem interrupções. Uso claude --dangerously-skip-permissions pra tarefas mecânicas: correção de lint, formatação, geração de boilerplate.

A chave é usar em ambiente controlado. No trabalho, sempre rodo numa branch separada. Em projetos pessoais, confio mais.

5. Q&A pra onboarding

O Claude Code é excelente pra explorar código novo. Faço as mesmas perguntas que faria pra outro engenheiro: "Como funciona o sistema de logs?", "Por que usamos foo() em vez de bar()?". O agente navega o código e responde.

"Leaf nodes": o segredo pra reduzir contexto

Um dos conceitos mais importantes: pensar em "leaf nodes". São partes do código que nada crítico depende. Lugares seguros pra deixar o agente trabalhar.

No frontend: quebre componentes grandes em pedaços menores. Dashboard monolítico vira <DashboardLayout>, <ChartSection>, <FilterBar>. Cada um é um contexto focado.

No backend: divida APIs grandes em módulos: users.py, auth.py, payments.py. Cada módulo vira um leaf node independente.

Dessa forma, fica muito mais fácil construir o contexto para você colocar o agente para trabalhar.

Context engineering: passando o contexto necessário ao Claude

Context Engineering é a disciplina de projetar e construir sistemas dinâmicos que fornecem a um Large Language Model (LLM) a informação certa, no formato certo e no momento certo para realizar uma tarefa. Em outras palavras, trata-se de "empacotar" a janela de contexto (a área de entrada de um LLM) da maneira mais eficiente possível. Fonte: AI Agents 101: O que é Context Engineering?

CLAUDE.md é sua memória persistente do Claude Code. Todo projeto novo, rodo /init pro agente criar o arquivo inicial. Depois refino com convenções do time.

Quando o agente repete erros, usando o comando # você consegue adicionar coisas em sua memória (aka CLAUDE.md):

# IMPORTANTE: Always use 'npm run test' instead of 'npm test'
# Database migrations go in migrations/ folder
# Never edit files in /dist - they are auto-generated

A chave é documentar padrões específicos do projeto que o Claude não pode adivinhar. E sempre incluir todo o contexto necessário para executar bem uma tarefa.

Isso tudo, além de incluir os arquivos principais da feature que você está fazendo, são o que fazem aumentar a qualidade de outputs que você recebe.

Há muito mais sobre context engineering a ser dito, mas estão fora do escopo desse artigo. Recomendo a leitura:

AI Agents 101: O que é Context Engineering?

A versatilidade surpreendente

Uma coisa que me impressiona no Claude Code é como ele se adapta a diferentes tipos de trabalho. Uso pra debugging complexo (ele navega stack traces e identifica problemas rapidamente), ajustes pixel-perfect de CSS (com Playwright pra verificar visualmente), e até pra explorar código desconhecido.

O segredo é a combinação de ferramentas. Claude Code + Playwright MCP funciona como um designer que testa suas próprias interfaces. Claude Code + git blame vira um arqueólogo de código que entende histórico e contexto.

Resultado: não preciso trocar de ferramenta dependendo da tarefa. Claude Code se tornou meu ambiente principal de desenvolvimento.

Dicas pra acelerar sua curva de aprendizado

Seja específico desde o início. Prompt vago = código ruim. Se você não consegue ser específico, primeiro precisa entender o problema. Use uma sessão de pair programming pra organizar as ideias.

Invista em ambiente dev rápido. Testes que demoram 30 segundos matam o feedback loop do agente. Ambiente rápido = iterações mais rápidas = melhor resultado final.

Configure CLAUDE.md no dia 1. Esse foi meu maior erro inicial. Passei alguns dias repetindo os mesmos contextos. Configure direito desde o começo.

TDD é sua rede de segurança. Permite confiar no agente sem ansiedade. Você define o comportamento esperado, ele implementa até passar.

Use poucos MCPs. Cada ferramenta MCP adiciona ruído ao contexto e pode piorar a qualidade das respostas. Teste antes de adicionar e mantenha apenas as que realmente agregam valor ao seu workflow. Até hoje, o único que adicionei foi o do Playwright.

Próximos passos

Se você quer experimentar esse workflow:

1. Comece com $20: substitua a sua assinatura do ChatGPT pelo Claude.ai (Sonnet > GPT 5). Com isso, você já pode usar o Claude Code similar ao Cursor.

2. Teste em projeto pessoal: não vá direto pra produção

3. Aprenda TDD: vai ser sua rede de segurança

4. Configure CLAUDE.md: documente suas convenções de código

5. Comece com leaf nodes: partes isoladas onde erros não são críticos

O futuro chegou. A questão não é mais se vamos usar IA pra coding, mas quão rápido vamos nos adaptar. Quem dominar esses agentes primeiro vai ter vantagem competitiva significativa.

🌟 Resumo

• Claude Code é diferente: agente puro de linha de comando que edita múltiplos arquivos sem supervisão constante, ideal pra features grandes

• Configuração é crucial: CLAUDE.md como memória persistente, comandos básicos (Escape, /clear), ambiente de desenvolvimento rápido

• Cinco workflows comprovados: explorar/planejar/codar, TDD como rede de segurança, iteração visual pra frontend, modo YOLO pra tarefas mecânicas, Q&A pra onboarding

• Pense em leaf nodes: trabalhe em partes isoladas do código onde erros não quebram funcionalidade crítica

• Limitações existem: não substitui debugging complexo, ajustes visuais precisos, ou exploração inicial de código desconhecido

O futuro não é IA substituindo programadores. É amplificação. Continuo definindo arquitetura e validando qualidade. Só que agora entrego em dias o que levaria semanas.

📚 Referências e leituras adicionais

• Claude Code in Action

• Claude Code best practices | Code w/ Claude

• Vibe coding in prod | Code w/ Claude

• Claude Code: Best practices for agentic coding

• Agentic Coding Recommendations

• Agentic Coding Things That Didn't Work