{
  "title": "Um Ano com o Cursor: Como Meu Fluxo de Trabalho Evoluiu de Agente para Arquiteto",
  "excerpt": "Minha jornada com o Cursor espelha a maturação da própria ferramenta: de um simples agente para um sofisticado parceiro arquitetural. Este post detalha como meu fluxo de trabalho evoluiu através de @ mentions, MCP, Plan Mode e custom commands.",
  "content_html": "<p>Já faz mais de um ano desde que tornei o Cursor meu 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 agentic em projetos pessoais, eu vivi a evolução do desenvolvimento nativo de IA. Minha jornada com o Cursor espelha a maturação da própria ferramenta: de um simples agente para um sofisticado parceiro arquitetural.</p>\n\n<p>Este post é uma reflexão sobre essa jornada, detalhando como meu fluxo de trabalho evoluiu e como passei a confiar em uma poderosa combinação de Plan Mode, custom commands e context engineering para construir mais rápido, de forma mais inteligente e com mais clareza.</p>\n\n<h2>Fase 1: O Agente Assume o Volante</h2>\n\n<p>Quando comecei, meu uso era simples. Eu tratava o Cursor como um autocomplete superpotente. Eu escrevia um comentário, apertava <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>Aí vieram os <strong>@ mentions</strong>. Essa foi minha primeira experiência em dar ao agente um contexto real. Em vez de esperar que ele entendesse meu codebase, eu podia dizer explicitamente 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 permitir que ele busque em todo o projeto</li>\n<li><code>@web</code> para trazer documentação externa</li>\n<li><code>@docs</code> para referenciar documentações oficiais de bibliotecas</li>\n</ul>\n\n<p>Esse foi um grande salto. De repente, o agente não estava mais adivinhando; ele estava trabalhando com o mesmo contexto que eu tinha. Eu podia dizer \"refatore essa função para corresponder ao padrão em <code>@file:utils/helpers.ts</code>\" e ele realmente entendia.</p>\n\n<img src=\"/assets/images/cursor-at-mentions.png\" alt=\"Cursor @ mention context\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">O dropdown de @ mention 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 um contexto melhor, eu frequentemente me encontrava em um loop de gerar, depurar e regenerar. O agente carecia da visão arquitetural 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 externas e fontes de dados, 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>Custom MCPs</strong> para APIs e bancos de dados internos</li>\n</ul>\n\n<p>Com o MCP, eu podia dizer \"implemente a feature descrita na Linear issue #234\" 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=\"MCP integrations in 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 customizados que estendem as capacidades do Cursor pelo ecossistema de desenvolvimento</span>\n\n<h2>Fase 3: A Ascensão do Planejador</h2>\n\n<p>A introdução do <strong>Plan Mode</strong> foi a próxima revolução. Foi a primeira vez que senti que estava colaborando com a IA, não apenas delegando para 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><strong>Plan with Opus:</strong> Eu usava um modelo poderoso como Claude Opus para gerar um plano de implementação detalhado, passo a passo. Eu dava a ele o objetivo de alto nível, e ele o dividia em uma série de tarefas concretas, com nomes de arquivos, assinaturas de funções e lógica completos.</li>\n<li><strong>Execute with Sonnet/GPT:</strong> Eu então passava 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; ele só precisava ser um construtor diligente.</li>\n</ol>\n\n<p>Esse fluxo de trabalho foi uma melhoria enorme. Ele separou o \"o quê\" do \"como\", e me deu um artefato revisável — o plano — que eu podia editar e aprovar antes que qualquer código fosse escrito. Também economizou um monte de dinheiro em tokens.</p>\n\n<img src=\"/assets/images/cursor-plan-mode.png\" alt=\"Cursor Plan Mode workflow\" 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 entre arquitetura e execução</span>\n\n<h2>Fase 4: O Arquiteto Emerge (Commands + Planning)</h2>\n\n<p>É aqui que vivo hoje. Enquanto o Plan Mode ainda é central no meu fluxo de trabalho, eu adicionei um conjunto de <strong>custom commands</strong> e <strong>rules</strong> para afinar o processo e incorporar meus princípios arquiteturais diretamente no IDE.</p>\n\n<h3>Minha Configuração Atual</h3>\n\n<p><strong>Rules (<code>.cursorrules</code>):</strong> Eu tenho um conjunto de regras que definem meus padrões de codificação, padrões preferidos e restrições arquiteturais. O agente lê essas regras antes de cada tarefa, garantindo consistência em todo o codebase.</p>\n\n<p><strong>Custom Commands:</strong> Eu construí comandos que encapsulam 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 um conjunto de testes para uma determinada função</li>\n<li><code>/review</code> - Revisa o código contra minhas regras e sugere melhorias</li>\n</ul>\n\n<p><strong>Queued Messages:</strong> Eu 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=\"Cursor custom commands and rules\" class=\"post-img\" width=\"1639\" height=\"935\" />\n<span class=\"post-img-caption\">A paleta de comandos do Cursor mostrando custom commands como /plan, /refactor, /test e /review, junto com um arquivo <code>.cursorrules</code> que define padrões de codificação e restrições arquiteturais</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>Agent Mode + @ Mentions</td>\n<td>O contexto tornou-se explícito, não adivinhado</td>\n</tr>\n<tr>\n<td>2</td>\n<td>MCP Integration</td>\n<td>Ferramentas e dados externos tornaram-se acessíveis</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Plan Mode</td>\n<td>Arquitetura separada da execução</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Commands + Rules</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>Essa evolução de agente para arquiteto é mais do que apenas um hack de produtividade pessoal. É um vislumbre do futuro do desenvolvimento de software. Estamos passando 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 que os agentes façam a construção.</p>\n\n<p>O Cursor, mais do que qualquer outra ferramenta que eu já usei, entende essa mudança. Não se trata apenas de gerar código; trata-se de gerenciar complexidade, manter contexto e dar aos desenvolvedores a alavancagem para construir em uma escala anteriormente inimaginável.</p>\n\n<p>Se você ainda está usando IA como um simples gerador de código, eu o incentivo a explorar @ mentions, MCP, Plan Mode e custom commands. É uma jornada que vai transformá-lo de um desenvolvedor que usa IA em um arquiteto que a dirige.</p>",
  "source_hash": "sha256:88320b9a62c7c3531ce3e1d3c838c4ff391eba9503c622827333c5c8d87cf3f6",
  "model": "moonshotai/kimi-k2.6",
  "generated_at": "2026-08-07T07:10:40.360104+00:00"
}