Finalmente Existe Um Motivo Para Mudar Para o Cursor

AAI LABS
Computing/SoftwareSmall Business/StartupsInternet Technology

Transcript

00:00:00Com o avanço da IA e o aumento do poder de cada novo modelo lançado,
00:00:03a forma como produzimos código foi completamente transformada.
00:00:07Agora existem muitas ferramentas especializadas em programação,
00:00:10como ClodCode,
00:00:11Cursor,
00:00:11Antigravity e outras,
00:00:12cada uma com suas próprias capacidades únicas.
00:00:14Mas bons modelos por si só não determinam a qualidade do código que você produz.
00:00:18Como você usa a ferramenta e gerencia o contexto importa tanto quanto.
00:00:22Todas essas ferramentas têm algum mecanismo inerente para engenharia de contexto,
00:00:25mas o Cursor acabou de fazer um grande avanço para uma nova abordagem,
00:00:28integrando-a nativamente no próprio aplicativo.
00:00:29Ao ler o artigo deles,
00:00:31percebi que esses princípios são genuinamente sólidos.
00:00:33Temos muito a conversar hoje porque essas ideias podem ser aplicadas amplamente a qualquer plataforma que você use para criar aplicações.
00:00:40O gerenciamento de contexto sempre foi crítico ao trabalhar com agentes de IA porque um bom gerenciamento de contexto determina a qualidade do resultado.
00:00:47Já falamos anteriormente em nossos vídeos sobre como o gerenciamento de contexto é importante e discutimos fluxos de trabalho para isso.
00:00:53O Cursor implementou recursos de gerenciamento de contexto diretamente em seu produto e lançou um artigo sobre isso.
00:00:58Esses princípios são baseados na observação deles de que,
00:01:01para obter bons resultados dos modelos,
00:01:03é melhor fornecer o mínimo de detalhes possível na janela de contexto.
00:01:06Quanto menos informação o modelo recebe de uma vez,
00:01:08menos dados ele precisa processar simultaneamente,
00:01:10o que significa menos confusão e mais foco na tarefa que ele precisa fazer no momento,
00:01:14porque apenas informações relevantes são incluídas.
00:01:17Essa abordagem é o que eles chamam de descoberta dinâmica de contexto.
00:01:20A ideia é a anotação estruturada.
00:01:22Ou seja,
00:01:22as informações que não são necessárias agora não devem estar na janela de contexto,
00:01:26excluindo detalhes potencialmente confusos ou contraditórios,
00:01:29o que melhora significativamente a qualidade das respostas do agente.
00:01:32A versão atual do Cursor adiciona cinco métodos de gerenciamento de contexto dinâmico que serão lançados em breve para os usuários.
00:01:37Embora o Cursor esteja implementando isso como uma atualização de produto,
00:01:41esses princípios são amplamente transferíveis para todos os agentes de IA.
00:01:44A primeira atualização mencionada pelo Cursor é que respostas longas de ferramentas devem ir para arquivos.
00:01:48MCPs frequentemente retornam respostas grandes que permanecem na janela de contexto.
00:01:52Nem todas as informações das respostas são sempre necessárias.
00:01:55O Cursor mencionou que a abordagem comum da maioria das ferramentas de programação é truncar respostas longas de MCP,
00:02:01o que leva à perda de dados ou informações importantes que podem ser necessárias para o contexto sendo removidas.
00:02:07A extensão do Chrome do Claude é uma extensão muito dependente de ferramentas,
00:02:10e apenas alguns prompts podem preencher o contexto devido ao carregamento de uma grande quantidade de dados na janela de contexto.
00:02:15Então adicionei uma instrução no arquivo Claude.md de que qualquer resposta de ferramenta MCP maior que 50 linhas deve ser salva em uma pasta MCP dentro da pasta .context executando um comando echo no terminal.
00:02:27Quando executei a extensão do Chrome para analisar a interface de uma landing page,
00:02:30sempre que o Claude encontrava uma ferramenta como ReadPage que infla significativamente a janela de contexto,
00:02:35ele salvava a resposta do MCP em um arquivo para leitura posterior,
00:02:39usando a qual analisou a página inteira e me forneceu um relatório.
00:02:42Essa solução alternativa melhorou a precisão da análise de resposta da ferramenta permitindo que o Claude analisasse as respostas dos arquivos quantas vezes fossem necessárias e eliminou a necessidade de chamadas repetitivas de ferramentas.
00:02:52Quando dados de chamadas MCP anteriores são necessários,
00:02:54o Claude pode lê-los diretamente da pasta .context em vez de fazer chamadas de ferramentas,
00:02:58economizando tempo significativo.
00:03:00Antes de passarmos para a próxima mudança,
00:03:02vamos ouvir nosso patrocinador,
00:03:03Zen Rose.
00:03:04Se você está desenvolvendo produtos de IA,
00:03:06automações ou sistemas orientados a dados,
00:03:08você já sabe uma coisa: tudo começa com dados web confiáveis.
00:03:11Mas obter dados limpos e estruturados em escala é mais difícil do que parece.
00:03:15É aí que o Zen Rose se encaixa perfeitamente na pilha..
00:03:18O Zen Rose cuida da extração de dados de sites complexos enquanto gerencia automaticamente o bypass anti-bot para que você possa se concentrar no que realmente importa: usar os dados.
00:03:27Em vez de lidar com resultados confusos,
00:03:29o Zen Rose entrega resultados estruturados como JSON ou Markdown prontos para serem integrados diretamente aos seus pipelines.
00:03:35É pronto para integração e focado em negócios,
00:03:37o que o torna ideal para startups de IA,
00:03:38equipes de dados e desenvolvedores de automação que não querem ficar monitorando infraestrutura..
00:03:43Seja enriquecendo leads,
00:03:44alimentando agentes de IA ou automatizando pesquisas,
00:03:46o Zen Rose simplesmente funciona.
00:03:48Se o seu trabalho depende de dados da web,
00:03:50o Zen Rose pertence à sua stack..
00:03:52Clique no link no comentário fixado e comece a desenvolver hoje.
00:03:55Sabemos que a etapa de sumarização quando a janela de contexto está cheia é confusa e leva à perda de muitas informações.
00:04:00A maioria das ferramentas,
00:04:02incluindo Cursor e Claude Code,
00:04:03aciona uma etapa de sumarização e inicia a sessão com uma janela de contexto nova tendo o resumo como ponto de partida..
00:04:09Quando você aperta compactar repetidamente,
00:04:11o resumo começa a esquecer detalhes que podem ser importantes para você,
00:04:14mas que o resumo do modelo pode perder.
00:04:16Há apenas um certo controle sobre a compactação automática,
00:04:19e a compressão repetida leva à perda de informações cruciais se você precisar fazê-lo repetidamente.
00:04:24A solução do Cursor é salvar todo o histórico de chat anterior como um arquivo para o agente consultar posteriormente.
00:04:30Quando fornecemos um prompt muito específico e o modelo não consegue encontrar a informação no resumo,
00:04:35a transcrição anterior serve como sua base de conhecimento.
00:04:37O modelo usa essa transcrição para gerar a solução,
00:04:40permitindo que recupere qualquer coisa que tenha sido perdida do resumo.
00:04:43Até que a implementação do Cursor seja lançada e fique disponível para todos,
00:04:47tentei implementar esse recurso com o Claude Code.
00:04:50Adicionei a instrução dentro do arquivo Claude.md para atualizar o histórico de chat após cada turno,
00:04:55documentando todas as decisões e etapas importantes.
00:04:58Ele usava uma pasta de histórico dentro da pasta .context,
00:05:00com o nome de cada arquivo refletindo a sessão.
00:05:03Então,
00:05:03sempre que peço para executar qualquer tarefa,
00:05:05ao final da sessão de execução da tarefa,
00:05:07ele documenta o histórico de chat no arquivo de histórico correspondente,
00:05:11adicionando tudo àquele arquivo.
00:05:12Dessa forma,
00:05:13a pasta .context contém registros detalhados de todas as sessões e tudo o que foi feito.
00:05:18Os agentes receberam habilidades para ajudar a gerenciar o problema de contexto que os MCPs estavam causando.
00:05:23O propósito geral das habilidades é fazer com que os agentes forneçam melhor capacidade de usar suas próprias funcionalidades,
00:05:28guiando através de scripts e arquivos de instrução,
00:05:30reduzindo o inchaço de contexto por meio de divulgação progressiva.
00:05:33A Anthropic foi a primeira a ter a ideia,
00:05:35que basicamente consiste em dar aos agentes um conjunto de instruções,
00:05:38scripts e recursos que o agente pode descobrir e usar para ter melhor desempenho em tarefas específicas.
00:05:43A Anthropic basicamente disponibilizou de código aberto essas habilidades dos agentes,
00:05:47estabelecendo um padrão que outros poderiam implementar.
00:05:50Após isso,
00:05:50Codex,
00:05:51Gemini e outros começaram a implementar habilidades de agentes,
00:05:53e finalmente chegou a vez do Cursor fazer o mesmo.
00:05:56As habilidades do Cursor são basicamente os mesmos executáveis e scripts agrupados em uma única habilidade que o agente pode usar para suas respectivas tarefas.
00:06:03Apenas o nome e a descrição das habilidades estão no contexto estático..
00:06:07Uma vez dentro do contexto estático,
00:06:08os agentes podem acessar suas habilidades por conta própria,
00:06:11usando grep e a busca semântica do Cursor.
00:06:13É isso que os torna diferentes,
00:06:15porque a busca semântica do Cursor usa seu próprio modelo de embeddings e pipelines de indexação nos bastidores,
00:06:20em vez de simples correspondência de padrões,
00:06:22como buscas baseadas em regex nos comandos grep.
00:06:24As habilidades do Claude expõem apenas o nome e a descrição no contexto,
00:06:28independentemente de quantos arquivos o script usa,
00:06:30evitando o inchaço do contexto.
00:06:32No meu projeto,
00:06:32eu havia configurado 5 habilidades,
00:06:34cada uma consumindo pouquíssimos tokens,
00:06:36apenas cerca de 0,
00:06:372% do total,
00:06:37deixando mais espaço para trabalhar.
00:06:39O diferencial é que as habilidades do Claude também podem ser acessadas via /comandos,
00:06:43permitindo que você as acione manualmente sempre que necessário,
00:06:46resolvendo as reclamações das pessoas sobre habilidades não sendo carregadas sob demanda adequadamente.
00:06:51Os MCPs contêm muitas ferramentas,
00:06:53todas expostas na janela de contexto,
00:06:54inchando-a desnecessariamente.
00:06:56O Cursor tomou para si a responsabilidade e enfatizou que cabe aos agentes de codificação,
00:07:00não aos servidores MCP,
00:07:01corrigir o inchaço do contexto.
00:07:02A solução para isso foi a descoberta dinâmica de contexto,
00:07:05sincronizando descrições de ferramentas em uma pasta.
00:07:08A ideia do Cursor é ter todos os MCPs com seus nomes em pastas separadas,
00:07:11nomeadas após cada MCP conectado,
00:07:13e dentro de cada pasta,
00:07:14todas as ferramentas devem ser listadas.
00:07:16Com isso,
00:07:16o agente recebe apenas os nomes das ferramentas e,
00:07:19sempre que precisa de alguma ferramenta,
00:07:20ele a procura nas pastas.
00:07:22Nos testes que fizeram,
00:07:23descobriram que a descoberta dinâmica de ferramentas MCP reduziu o uso em 46,
00:07:269%,
00:07:27o que faz uma enorme diferença se você está trabalhando em um sistema de longa execução.
00:07:31Esta implementação também ajuda em casos onde os servidores MCP são acidentalmente desconectados ou exigem reautenticação.
00:07:37Normalmente,
00:07:37o sistema simplesmente esqueceria essas ferramentas,
00:07:40mas agora o agente pode realmente notificar o usuário de que a reautenticação é necessária.
00:07:44O Claude também possui uma ferramenta de busca avançada projetada especificamente para resolver esse problema,
00:07:49usando um conjunto específico de flags para informar ao Claude se deve carregá-la ou não.
00:07:54Ela implementa a ideia exata do Cursor de descoberta dinâmica de contexto,
00:07:57mas isso é limitado à plataforma de desenvolvimento e apenas para quem está construindo com APIs.
00:08:02Não podemos modificar como os MCPs são usados no Claude Code,
00:08:05porque eles são integrados pela Anthropic.
00:08:07Justo quando eu procurava formas de implementar isso no Claude Code,
00:08:10encontrei uma flag oculta.
00:08:11Sem configurar essa flag,
00:08:12todas as ferramentas MCP que eu tinha conectado eram expostas no contexto do Claude Code.
00:08:16Quando defini a flag enable experimental MCP CLI,
00:08:19todas as ferramentas foram removidas da janela de contexto,
00:08:21liberando espaço que estava anteriormente ocupado pelas ferramentas MCP.
00:08:25Mas isso não significa que os MCPs sejam desconectados quando este CLI é ativado.
00:08:29A única diferença é que eles não são expostos antecipadamente na janela de contexto.
00:08:33Em vez de colocar todos os schemas no contexto,
00:08:35o Claude agora usa uma camada intermediária bash chamada MCP CLI,
00:08:38que lida com todas as tarefas relacionadas ao MCP.
00:08:40O Claude usa essa camada intermediária para buscar,
00:08:43obter informações e invocar as ferramentas.
00:08:45Sempre que você pede ao Claude para realizar qualquer tarefa que exija uma chamada de ferramenta MCP,
00:08:50em vez de usar o método usual,
00:08:51ele usa os MCPs via MCP CLI e executa a tarefa que lhe foi solicitada.
00:08:54Ao usar essa ferramenta,
00:08:55o Claude executa todas as tarefas normalmente,
00:08:58apenas através dessa camada intermediária.
00:09:00Relatar erros de terminal é difícil no Cursor por causa de seu acesso limitado.
00:09:03Se o terminal mostrava algum erro,
00:09:05você precisava adicioná-lo ao chat e então fazê-lo corrigir.
00:09:08A solução do Cursor para isso também é mover as sessões de terminal para arquivos.
00:09:12Então,
00:09:12sempre que você faz qualquer pergunta,
00:09:14ele referencia esses arquivos de histórico e usa grep para extrair a saída relevante..
00:09:20Como os logs de servidor geralmente são longos e contêm muito ruído para o agente,
00:09:24usar a tarefa grep é mais eficiente porque permite que o agente faça correspondência de padrões.
00:09:29Eles tiraram essa ideia de agentes de codificação baseados em CLI,
00:09:32que executam os comandos,
00:09:33mas depois a saída é injetada no contexto exatamente da maneira que o Claude Code e outros fazem por padrão.
00:09:38Embora o Claude lide com isso de forma inteligente por conta própria,
00:09:42podemos gerenciar ainda mais usando instruções no Claude.md para instruí-lo a adicionar todos os logs de terminal em um arquivo na pasta terminal dentro da pasta .context.
00:09:50Basicamente,
00:09:51se o Claude executar qualquer comando npm,
00:09:53ele executa um comando especial que registra tanto o fluxo de saída quanto o fluxo de entrada nos arquivos de documento.
00:09:58Aqui,
00:09:592 representa o fluxo de erro padrão e 1 representa o fluxo de saída padrão.
00:10:02Ele grava esses logs na pasta terminal,
00:10:04marcando-os com um carimbo de data/hora.
00:10:06Então,
00:10:07sempre que precisar pesquisá-los,
00:10:08ele simplesmente usa um comando grep com um padrão especificado e carrega as últimas 20 linhas para extrair apenas o que importa..
00:10:15Então,
00:10:15sempre que testei meu servidor de desenvolvimento,
00:10:18ele usou esses comandos e continuou gravando as execuções do terminal em arquivos de acordo com o arquivo Claude.md.
00:10:23Depois de executar o servidor,
00:10:24ele consultou os arquivos de log e descobriu o que estava causando o problema e resolveu o erro para mim..
00:10:29Agora,
00:10:29embora esse complemento ao Claude Code possa parecer insignificante porque não parece ter muito impacto no trabalho imediato,
00:10:35pode ser muito útil quando você quiser consultar o funcionamento do seu aplicativo.
00:10:39Assim como quando precisei identificar qual serviço estava causando a falha do meu aplicativo,
00:10:43simplesmente disse ao Claude para consultar os logs de teste em vez de executar os testes novamente,
00:10:47evitando ter que reexecutar uma suíte de testes de 2 minutos apenas para reproduzir um erro que eu já havia visto.
00:10:52Isso nos traz ao fim deste vídeo.
00:10:54Se você gostaria de apoiar o canal e nos ajudar a continuar fazendo vídeos como este,
00:10:58pode fazê-lo usando o botão Super Thanks abaixo.
00:11:00Como sempre, obrigado por assistir e te vejo no próximo..

Key Takeaway

O Cursor revolucionou o gerenciamento de contexto em ferramentas de programação com IA através da descoberta dinâmica de contexto, princípios que podem ser aplicados a qualquer plataforma para melhorar significativamente a qualidade do código gerado.

Highlights

O Cursor implementou descoberta dinâmica de contexto para melhorar a qualidade do código gerado por IA, mantendo apenas informações relevantes na janela de contexto

Respostas longas de ferramentas MCP devem ser salvas em arquivos separados ao invés de permanecerem na janela de contexto, evitando truncamento e perda de dados

Todo o histórico de chat anterior deve ser salvo como arquivo para consulta futura, resolvendo o problema de perda de informações durante a compactação automática

A descoberta dinâmica de ferramentas MCP reduziu o uso de contexto em 46,9%, expondo apenas nomes de ferramentas no contexto estático

Habilidades de agentes permitem divulgação progressiva de funcionalidades através de scripts e instruções, consumindo apenas 0,2% do contexto total

Logs de terminal devem ser movidos para arquivos e consultados via grep quando necessário, ao invés de serem injetados diretamente no contexto

Timeline

Introdução ao gerenciamento de contexto em ferramentas de IA

O vídeo apresenta como a IA transformou completamente a forma de produzir código, destacando ferramentas especializadas como ClodCode, Cursor e Antigravity. O apresentador enfatiza que bons modelos sozinhos não determinam a qualidade do código - o gerenciamento de contexto é igualmente crucial. O Cursor fez um grande avanço integrando nativamente uma nova abordagem de gerenciamento de contexto no aplicativo. A descoberta dinâmica de contexto baseia-se no princípio de fornecer o mínimo de detalhes possível na janela de contexto, permitindo que o modelo processe menos dados simultaneamente e mantenha foco apenas em informações relevantes.

Primeiro método: Salvar respostas longas de ferramentas em arquivos

O Cursor identificou que MCPs frequentemente retornam respostas grandes que inflam a janela de contexto, e a solução comum de truncar essas respostas leva à perda de dados importantes. A implementação prática demonstrada envolve adicionar instruções no arquivo Claude.md para salvar automaticamente qualquer resposta de ferramenta MCP maior que 50 linhas em uma pasta MCP dentro da pasta .context. Quando testado com a extensão do Chrome do Claude analisando uma landing page, a ferramenta ReadPage salvou suas respostas em arquivos para leitura posterior ao invés de inflar o contexto. Essa solução melhorou significativamente a precisão da análise, permitindo que o Claude consulte os arquivos quantas vezes necessário e eliminando chamadas repetitivas de ferramentas, economizando tempo considerável.

Segundo método: Preservar histórico de chat em arquivos

A etapa de sumarização quando a janela de contexto está cheia é confusa e leva à perda de muitas informações importantes. A maioria das ferramentas, incluindo Cursor e Claude Code, aciona sumarização automática e inicia nova sessão com resumo como ponto de partida. A compactação repetida faz o resumo esquecer detalhes cruciais que o modelo pode perder. A solução do Cursor é salvar todo o histórico de chat anterior como arquivo que o agente pode consultar posteriormente, servindo como base de conhecimento quando informações específicas não estão no resumo. A implementação no Claude Code envolveu adicionar instruções para atualizar o histórico após cada turno em uma pasta de histórico dentro de .context, documentando todas as decisões e etapas importantes de cada sessão.

Terceiro método: Habilidades de agentes com divulgação progressiva

As habilidades de agentes foram desenvolvidas para resolver o problema de contexto causado pelos MCPs, fornecendo melhor capacidade de usar funcionalidades através de scripts e arquivos de instrução. A Anthropic foi pioneira nessa ideia, disponibilizando código aberto e estabelecendo um padrão que Codex, Gemini e Cursor implementaram posteriormente. As habilidades do Cursor agrupam executáveis e scripts em uma única habilidade, expondo apenas nome e descrição no contexto estático - os agentes acessam o conteúdo por conta própria usando grep e busca semântica. O diferencial é que essa busca semântica usa modelo de embeddings e pipelines de indexação próprios ao invés de simples correspondência de padrões regex. No exemplo prático, 5 habilidades configuradas consumiram apenas 0,2% do contexto total, e podem ser acionadas manualmente via /comandos quando necessário.

Quarto método: Descoberta dinâmica de ferramentas MCP

Os MCPs contêm muitas ferramentas todas expostas na janela de contexto, inchando-a desnecessariamente. O Cursor enfatizou que cabe aos agentes de codificação, não aos servidores MCP, corrigir esse inchaço. A solução de descoberta dinâmica de contexto envolve sincronizar descrições de ferramentas em pastas separadas nomeadas após cada MCP conectado, listando todas as ferramentas dentro. Com isso, o agente recebe apenas os nomes das ferramentas e as procura nas pastas quando necessário. Nos testes do Cursor, essa descoberta dinâmica reduziu o uso de contexto em 46,9%, fazendo enorme diferença em sistemas de longa execução. Essa implementação também ajuda quando servidores MCP são desconectados ou exigem reautenticação, permitindo que o agente notifique o usuário ao invés de simplesmente esquecer as ferramentas.

Implementação da descoberta dinâmica no Claude Code

O Claude possui ferramenta de busca avançada implementando a ideia exata do Cursor de descoberta dinâmica de contexto, mas limitada à plataforma de desenvolvimento e APIs. A solução encontrada foi uma flag oculta 'enable experimental MCP CLI' que remove todas as ferramentas MCP da janela de contexto quando ativada. Isso não desconecta os MCPs - apenas os torna não expostos antecipadamente no contexto. Ao invés de colocar todos os schemas no contexto, o Claude usa camada intermediária bash chamada MCP CLI que lida com todas as tarefas relacionadas ao MCP. Sempre que uma tarefa exige chamada de ferramenta MCP, o Claude usa essa camada intermediária para buscar, obter informações e invocar as ferramentas, executando tudo normalmente mas através dessa camada.

Quinto método: Mover sessões de terminal para arquivos

Relatar erros de terminal é difícil no Cursor por causa de seu acesso limitado - anteriormente era necessário adicionar erros ao chat manualmente. A solução do Cursor é mover sessões de terminal para arquivos, permitindo que o agente referencie históricos e use grep para extrair saída relevante. Como logs de servidor são longos e contêm muito ruído, usar grep é mais eficiente para correspondência de padrões. A implementação no Claude Code envolve instruções no Claude.md para adicionar logs de terminal em arquivo na pasta terminal dentro de .context. Quando o Claude executa comandos npm, um comando especial registra fluxos de saída (1) e erro (2) em arquivos com carimbo de data/hora. Sempre que necessário pesquisar, o Claude usa comando grep com padrão especificado carregando últimas 20 linhas para extrair apenas o que importa.

Benefícios práticos e conclusão

Embora o complemento possa parecer insignificante por não ter impacto imediato aparente, é muito útil para consultar o funcionamento do aplicativo posteriormente. O exemplo prático demonstra identificar qual serviço causava falha do aplicativo consultando logs de teste ao invés de reexecutar testes, evitando reexecutar uma suíte de 2 minutos apenas para reproduzir erro já visto. Essa abordagem economiza tempo significativo e permite análise retrospectiva eficiente. O vídeo conclui destacando que esses princípios de gerenciamento de contexto implementados pelo Cursor podem ser aplicados amplamente a qualquer plataforma de desenvolvimento com IA.

Community Posts

View all posts