{
  "title": "Um Ano com Cursor: Como Meu Fluxo de Trabalho Evoluiu de Agente para Arquiteto",
  "excerpt": "Minha jornada com o Cursor reflete a maturação da própria ferramenta: de um simples agente para um parceiro arquitetônico sofisticado. Este post detalha como meu fluxo de trabalho evoluiu através de menções @, MCP, Modo de Planejamento e comandos personalizados.",
  "content_html": "<p>Já faz mais de um ano desde que tornei o Cursor minha IDE principal, e é difícil exagerar o impacto que ele teve no meu trabalho. Como engenheiro de machine learning construindo plataformas de IA conversacional na Dylog e experimentando com infraestrutura agêntica em meus projetos pessoais, vivi a evolução do desenvolvimento nativo de IA. Minha jornada com o Cursor reflete a maturação da própria ferramenta: de um simples agente para um parceiro arquitetônico sofisticado.</p>\n\n<p>Este post é uma reflexão sobre essa jornada, detalhando como meu fluxo de trabalho evoluiu e como passei a depender de uma combinação poderosa de Modo de Planejamento, comandos personalizados e engenharia de contexto para construir mais rápido, de forma mais inteligente e com mais clareza.</p>\n\n<h2>Fase 1: O Agente Assume o Controle</h2>\n\n<p>Quando comecei, meu uso era simples. Eu tratava o Cursor como um autocompletar turbinado. Eu escrevia um comentário, pressionava <code>Cmd+K</code> e deixava o agente gerar o código. Era mágico, mas também era uma caixa preta. Eu era um passageiro, e o agente estava dirigindo.</p>\n\n<p>Então vieram as <strong>menções @</strong>. Este foi meu primeiro gostinho de dar contexto real ao agente. Em vez de esperar que ele entendesse minha base de código, eu podia explicitamente dizer o que olhar:</p>\n\n<ul>\n<li><code>@file</code> para referenciar um arquivo específico</li>\n<li><code>@folder</code> para incluir um diretório inteiro</li>\n<li><code>@codebase</code> para deixá-lo buscar em todo o projeto</li>\n<li><code>@web</code> para trazer documentação externa</li>\n<li><code>@docs</code> para referenciar documentação oficial de bibliotecas</li>\n</ul>\n\n<p>Isso foi um grande salto. De repente, o agente não estava adivinhando; estava trabalhando com o mesmo contexto que eu tinha. Eu podia dizer \"refatore esta função para corresponder ao padrão em <code>@file:utils/helpers.ts</code>\" e ele realmente entenderia.</p>\n\n<img src=\"/assets/images/cursor-at-mentions.png\" alt=\"Contexto de menção @ do Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">O menu suspenso de menção @ no Cursor, mostrando opções de contexto como @file, @folder, @codebase, @web e @docs que permitem controle explícito de contexto</span>\n\n<p>Mas mesmo com melhor contexto, eu frequentemente me encontrava em um loop de gerar, depurar e regenerar. O agente carecia da visão arquitetônica para tarefas maiores.</p>\n\n<h2>Fase 2: MCP Muda Tudo</h2>\n\n<p>A introdução do <strong>Model Context Protocol (MCP)</strong> foi quando as coisas ficaram sérias. O MCP me permitiu conectar o Cursor a ferramentas e fontes de dados externas, transformando o agente de um gerador de código em um verdadeiro assistente com acesso a todo o meu fluxo de trabalho.</p>\n\n<p>Comecei a integrar MCPs para:</p>\n\n<ul>\n<li><strong>GitHub</strong> para trazer issues e PRs diretamente para o contexto</li>\n<li><strong>Linear</strong> para integração de gerenciamento de tarefas</li>\n<li><strong>Slack</strong> para contexto de comunicação da equipe</li>\n<li><strong>MCPs personalizados</strong> para APIs internas e bancos de dados</li>\n</ul>\n\n<p>Com o MCP, eu podia dizer \"implemente a funcionalidade descrita na issue #234 do Linear\" e o agente buscaria a issue, entenderia os requisitos e começaria a construir. Não era mais apenas sobre código; era sobre conectar os pontos em todo o meu ecossistema de desenvolvimento.</p>\n\n<img src=\"/assets/images/cursor-mcp-integrations.png\" alt=\"Integrações MCP no Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">Painel de configuração do MCP mostrando integrações conectadas como GitHub, Linear, Slack e servidores personalizados que estendem as capacidades do Cursor por todo o ecossistema de desenvolvimento</span>\n\n<h2>Fase 3: A Ascensão do Planejador</h2>\n\n<p>A introdução do <strong>Modo de Planejamento</strong> foi o próximo divisor de águas. Foi a primeira vez que senti que estava colaborando com a IA, não apenas delegando a ela. Inspirado por fluxos de trabalho de desenvolvedores como Ray Fernando, comecei a usar um processo de duas etapas:</p>\n\n<ol>\n<li><p><strong>Planejar com Opus:</strong> Eu usaria um modelo poderoso como Claude Opus para gerar um plano de implementação detalhado, passo a passo. Eu daria o objetivo de alto nível, e ele dividiria em uma série de tarefas concretas, completas com nomes de arquivos, assinaturas de funções e lógica.</p></li>\n\n<li><p><strong>Executar com Sonnet/GPT:</strong> Eu então passaria esse plano para um modelo mais rápido e barato como Sonnet ou GPT-5.2 para executar cada etapa. O modelo mais barato não precisava ser um arquiteto brilhante; só precisava ser um construtor diligente.</p></li>\n</ol>\n\n<p>Este fluxo de trabalho foi uma melhoria massiva. Ele separou o \"o quê\" do \"como\", e me deu um artefato revisável—o plano—que eu podia editar e aprovar antes de qualquer código ser escrito. Também economizou uma tonelada de dinheiro em tokens.</p>\n\n<img src=\"/assets/images/cursor-plan-mode.png\" alt=\"Fluxo de trabalho do Modo de Planejamento do Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">Uma visualização dividida mostrando um plano de implementação detalhado em um arquivo <code>.cursor/plans/</code> à esquerda, e o código gerado correspondente à direita, demonstrando a separação da arquitetura da execução</span>\n\n<h2>Fase 4: O Arquiteto Emerge (Comandos + Planejamento)</h2>\n\n<p>É aqui que vivo hoje. Embora o Modo de Planejamento ainda seja central no meu fluxo de trabalho, adicionei um conjunto de <strong>comandos personalizados</strong> e <strong>regras</strong> para ajustar o processo e incorporar meus princípios arquitetônicos diretamente na IDE.</p>\n\n<h3>Minha Configuração Atual</h3>\n\n<p><strong>Regras (<code>.cursorrules</code>):</strong> Tenho um conjunto de regras que definem meus padrões de codificação, padrões preferidos e restrições arquitetônicas. O agente lê estas antes de cada tarefa, garantindo consistência em toda a base de código.</p>\n\n<p><strong>Comandos Personalizados:</strong> Construí comandos que envolvem meus fluxos de trabalho mais comuns:</p>\n\n<ul>\n<li><code>/plan</code> - Gera um plano de implementação detalhado usando Opus</li>\n<li><code>/refactor</code> - Pega um arquivo e o refatora com base em instruções</li>\n<li><code>/test</code> - Gera uma suíte de testes para uma determinada função</li>\n<li><code>/review</code> - Revisa código contra minhas regras e sugere melhorias</li>\n</ul>\n\n<p><strong>Mensagens em Fila:</strong> Uso <code>Ctrl+Enter</code> para enfileirar instruções de acompanhamento enquanto o agente está trabalhando. Isso me permite pensar à frente e manter o momentum sem interromper a tarefa atual.</p>\n\n<img src=\"/assets/images/cursor-custom-commands.png\" alt=\"Comandos personalizados e regras do Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">A paleta de comandos do Cursor mostrando comandos personalizados como /plan, /refactor, /test e /review, ao lado de um arquivo <code>.cursorrules</code> que define padrões de codificação e restrições arquitetônicas</span>\n\n<h2>A Evolução em Resumo</h2>\n\n<table>\n<thead>\n<tr>\n<th>Fase</th>\n<th>Recurso Principal</th>\n<th>O Que Mudou</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Modo Agente + Menções @</td>\n<td>Contexto tornou-se explícito, não adivinhado</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Integração MCP</td>\n<td>Ferramentas e dados externos tornaram-se acessíveis</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Modo de Planejamento</td>\n<td>Arquitetura separada da execução</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Comandos + Regras</td>\n<td>Fluxos de trabalho tornaram-se repetíveis e personalizados</td>\n</tr>\n</tbody>\n</table>\n\n<h2>Por Que Isso Importa</h2>\n\n<p>Esta evolução de agente para arquiteto é mais do que apenas um hack de produtividade pessoal. É um vislumbre do futuro do desenvolvimento de software. Estamos nos movendo de um mundo onde escrevemos código para um mundo onde <strong>descrevemos sistemas</strong>. Nosso trabalho é ser o arquiteto, definir o blueprint, e deixar os agentes fazerem a construção.</p>\n\n<p>O Cursor, mais do que qualquer outra ferramenta que usei, entende essa mudança. Não é apenas sobre gerar código; é sobre gerenciar complexidade, manter contexto e dar aos desenvolvedores a alavancagem para construir em uma escala que era anteriormente inimaginável.</p>\n\n<p>Se você ainda está usando IA como um simples gerador de código, encorajo você a explorar menções @, MCP, Modo de Planejamento e comandos personalizados. É uma jornada que transformará você de um desenvolvedor que usa IA para um arquiteto que a dirige.</p>",
  "source_hash": "sha256:c11c23550cdc336e503f564506c299fa36379c99fe4b8cff420d4a83f91c4e64",
  "model": "claude-sonnet-4-5-20250929",
  "generated_at": "2026-01-15T20:25:01.791212+00:00"
}