Amplitude entrega 3x mais código em produção com Cursor
A Amplitude usa o Cursor para criar um pipeline de desenvolvimento autônomo que leva o software da ideia à produção com o mínimo de intervenção dos desenvolvedores.
A equipe de engenharia da Amplitude queria criar um pipeline de desenvolvimento totalmente autônomo que pudesse levar o software da ideia à produção com o mínimo de intervenção dos desenvolvedores. Com o Cursor, a Amplitude agora configurou sistemas que capturam contexto de todo o ciclo de vida do software–de feedback de clientes a ferramentas de observabilidade e revisões de código–e o encaminham para agentes executarem.
Agora, quando clientes relatam bugs ou solicitações de recursos no Slack, agentes na nuvem são acionados automaticamente para investigar, abrir um ticket e criar uma correção. As Automações do Cursor são executadas continuamente em segundo plano, migrando código legado e classificando níveis de risco para cada PR novo ou atualizado. O Bugbot atua como a primeira linha de revisão, mesclando automaticamente alterações de baixo risco e encaminhando PRs de alto risco aos revisores certos.
A maioria das ferramentas de IA para programação entrega mais código. O Cursor entrega mais software de produção útil. A capacidade de executar agentes que conseguem paralelizar o trabalho com eficácia, testar as próprias alterações e levar uma funcionalidade da ideia à produção é o diferencial.
Agentes exclusivamente locais limitam o paralelismo e a autonomia
No início da adoção de agentes de programação, a Amplitude esbarrou no que Adam Lohner, engenheiro de software staff, descreveu como um falso platô na produtividade de engenharia.
Os verdadeiros ganhos de velocidade no desenvolvimento vêm quando os agentes produzem software de produção realmente útil, e não apenas muito código. Para isso, precisávamos de muito mais paralelismo e autonomia dos agentes — algo que agentes restritos às estações de trabalho locais dos desenvolvedores não oferecem.
Os agentes locais disputam o mesmo conjunto limitado de recursos e rapidamente acabam gerando conflitos. Até mesmo executar dois ou três agentes ao mesmo tempo pode causar queda de performance. A base de código da Amplitude é grande o bastante para que as máquinas locais dos desenvolvedores chegassem ao limite de memória, mesmo em hardware de ponta com muita RAM.
Os agentes locais também não têm acesso a um ambiente de desenvolvimento completo como um engenheiro teria. Sem isso, os agentes não conseguem testar nem verificar o próprio trabalho. Os desenvolvedores ainda precisam configurar ambientes, executar testes de ponta a ponta e verificar manualmente as alterações antes que qualquer coisa possa ser entregue.
A nuvem leva os agentes além dos limites locais
Para ganhar mais paralelismo e autonomia, a Amplitude recorreu aos agentes na nuvem do Cursor. Algumas capacidades se destacaram:
- Execução paralela em escala: agentes na nuvem rodam em VMs isoladas e escaláveis, eliminando as restrições de recursos que limitam o paralelismo local.
- Ambiente de desenvolvimento completo: agentes na nuvem podem testar, verificar e iterar sobre o próprio trabalho como um engenheiro faria, com acesso a um ambiente de desenvolvimento completo.
- Execução de longa duração: a Amplitude está delegando tarefas mais profundas e ambiciosas para que os agentes na nuvem executem de ponta a ponta, em vez de tarefas curtas e síncronas.
- Agentes sempre ativos: as Automações do Cursor permitem que a Amplitude configure agentes na nuvem para rodar em resposta a gatilhos ou agendamentos recorrentes, em vez de comandos manuais.
Estamos rodando muitos agentes na nuvem ao mesmo tempo no Cursor, cada um com acesso total ao nosso stack de ferramentas. A capacidade de subir agentes que não esbarram em limitações locais de recursos nem exigem microgerenciamento constante representou uma mudança enorme.
Os engenheiros da Amplitude agora alternam entre agentes na nuvem e locais, dependendo do tipo de trabalho. Novas ideias muitas vezes começam na nuvem, onde a infraestrutura do Cursor permite que os agentes trabalhem de forma independente por longos períodos. Muitos engenheiros iniciam o Cursor diretamente de threads no Slack em que ideias de funcionalidades estão sendo discutidas.
Os desenvolvedores trazem os agentes para o ambiente local quando estão prontos para se concentrar em uma iteração mais controlada ou analisar os detalhes mais de perto. O Cursor funciona como o espaço de trabalho unificado entre nuvem e ambiente local.
O Cursor oferece a melhor interface para orquestrar todos os seus agentes paralelos. Você pode trabalhar em alto nível ou mergulhar em detalhes como diffs e arquivos quando precisar.
Desde a adoção dos agentes na nuvem, a Amplitude registrou um aumento de 3x nos commits semanais em produção. O Cursor se tornou um dos três principais contribuidores da base de código da Amplitude por volume de commits, com mais de 1.000 execuções de agentes iniciadas toda semana sem nenhum prompt nem intervenção de desenvolvedores.
A nuvem é onde o software é desenvolvido; o ambiente local é onde testamos e iteramos. O suporte do Cursor para handoffs fluidos entre os dois foi o que destravou a velocidade de produto da Amplitude.
Do Slack ao ticket e ao PR
A Amplitude tem canais dedicados no Slack onde as equipes de campo repassam relatos de bugs de clientes e solicitações de novos recursos. Antes do Cursor, eles tinham um membro da equipe dedicado a monitorar esses canais, fazer a triagem dos problemas, acompanhar os tickets e atribuir tarefas do backlog.
Então, Pauly criou uma Automação do Cursor para transferir todo esse fluxo de trabalho para agentes. Quando uma nova mensagem aparece no Slack, um agente na nuvem verifica no Linear se já existe um ticket para o problema. Se existir, o agente adiciona o novo contexto do cliente. Caso contrário, o agente explora a base de código, abre um novo ticket e abre um PR com a solução implementada.
As Automações do Cursor estão nos ajudando a eliminar a lacuna entre o cliente e nossos engenheiros. Estamos atendendo às necessidades dos clientes com mais rapidez e com soluções melhores.
Você pode começar a desenvolver uma automação para transformar relatos do Slack em PRs com este modelo.
Refatoração automatizada de código legado
A base de código de frontend da Amplitude havia acumulado anos de padrões conflitantes, incluindo componentes CSS legados, layouts React desatualizados e convenções de estilo inconsistentes.
Temos tantos padrões legados conflitantes que os agentes têm dificuldade para interpretar qual é o caminho ideal a seguir. É um caso clássico de entra lixo, sai lixo.
Para resolver isso, Lohner desenvolveu um conjunto de Automações do Cursor baseadas em cron, executadas de hora em hora para avançar gradualmente nas migrações do legado. Uma automação analisa arquivos CSS em busca de estilos que podem ser substituídos diretamente por classes Tailwind, faz as substituições, exclui os arquivos antigos, abre uma PR e publica uma notificação no Slack. Outra percorre as mais de 20.000 ocorrências de componentes legados de layout em React da Amplitude, trocando-as por equivalentes nativos do Tailwind.
Executar essas migrações na nuvem como automações significa que elas acontecem continuamente em segundo plano, sem atrapalhar outros trabalhos nem consumir o tempo dos desenvolvedores.
Revisão de código conduzida por agente
O outro gargalo que reduzia a velocidade de engenharia da Amplitude era a revisão manual de código. A Amplitude queria um processo de revisão orientado por agentes que melhorasse a confiabilidade do produto e causasse menos interrupções para os desenvolvedores.
A Amplitude implementou o Bugbot como sua camada dedicada de revisão agêntica. A adoção cresceu de forma orgânica à medida que os desenvolvedores viam o Bugbot identificar problemas que os revisores humanos deixavam passar, dada a escala e a complexidade da base de código da Amplitude.
O Bugbot encontra bugs realmente difíceis com frequência e propõe correções sólidas para esses problemas.
Lohner também desenvolveu uma Automação do Cursor que avalia o nível de risco de cada PR. Alterações de baixo risco podem seguir para mesclagem, com o Bugbot revisando e corrigindo problemas automaticamente, sem intervenção do desenvolvedor. PRs de alto risco com mudanças de lógica mais complexas são encaminhados automaticamente para os engenheiros mais adequados. Cerca de 60% a 70% dos PRs de baixo risco são mesclados sem nenhum trabalho adicional do desenvolvedor. Você pode começar a desenvolver uma automação para transformar relatos do Slack em PRs com este modelo.
O histórico do Bugbot de identificar com frequência bugs reais que ameaçam a produção fez dele uma parte essencial do nosso processo de revisão de código.
Em seguida, a Amplitude está focada em levar as automações para a segunda metade do ciclo de desenvolvimento: pipelines de CI/CD, validação de build e implantação. O objetivo é fazer com que agentes levem o software de um PR revisado até a produção sem intervenção do desenvolvedor.
Se você tem interesse em desenvolver pipelines autônomos de desenvolvimento com o Cursor, entre em contato com nossa equipe para iniciar um teste do Cursor.
