Os Minions da Stripe e a nova era dos agentes autônomos de codificação
Os Minions chegaram, e não estamos falando dos personagens amarelos do cinema não 😄
A Stripe, uma das maiores empresas de pagamentos do mundo, criou agentes autônomos de codificação que estão transformando o jeito que software é desenvolvido lá dentro.
O número que chama atenção logo de cara é este: mais de 1.300 pull requests gerados por semana, de forma automática, sem que nenhuma linha de código tenha sido escrita por um ser humano.
Mas calma, isso não significa que os engenheiros foram mandados embora.
Todo o código produzido por esses agentes passa por revisão humana antes de ir para produção.
O que mudou é outra coisa: os engenheiros pararam de escrever código repetitivo e passaram a focar no que realmente importa, que é revisar, validar e tomar decisões estratégicas.
Parece futuro, mas já está acontecendo agora, dentro de uma infraestrutura que processa mais de 1 trilhão de dólares em pagamentos por ano.
Então a pergunta que fica é: como exatamente esse sistema funciona, e o que ele representa para o desenvolvimento de software daqui pra frente?
É exatamente isso que a gente vai explorar aqui. 🚀
O que são os Minions da Stripe?
Os Minions são, na prática, agentes autônomos desenvolvidos internamente pela Stripe para executar tarefas de codificação de forma independente. O nome é informal, mas o conceito por trás é bastante sofisticado. Esses agentes são alimentados por modelos de linguagem de grande escala, os famosos LLMs, e foram configurados para entender o contexto do repositório de código da Stripe, identificar tarefas que podem ser automatizadas e gerar soluções funcionais em cima disso.
- E-BOOK GRATUITO
Um guia prático para avaliar, comparar e implementar inteligência artificial com clareza — sem desperdício de tempo ou dinheiro.
Pare de contratar ferramentas sem direção. Criamos um método estruturado para decidir qual IA realmente faz sentido para o seu negócio.
Entrega em PDF no seu e-mail · Sem spam · LGPD
🔒 Seus dados são protegidos conforme a LGPD. Você pode descadastrar a qualquer momento.
Não se trata de um simples autocomplete ou de uma ferramenta que sugere linhas de código enquanto você digita. Os Minions operam de ponta a ponta em determinadas tarefas, desde a leitura do problema até a abertura de um pull request completo, pronto para ser revisado por um engenheiro humano.
O que diferencia essa abordagem de outras ferramentas de IA no mercado é justamente o nível de autonomia envolvido. Enquanto ferramentas como o GitHub Copilot funcionam como assistentes que reagem ao que o desenvolvedor está fazendo, e editores de código baseados em IA como o Cursor ainda dependem de supervisão humana constante, os Minions agem de forma proativa. Eles recebem uma tarefa, planejam os passos necessários para resolver o problema, navegam pelo código existente, fazem alterações coerentes com o padrão da base de código e entregam um resultado estruturado. Esse tipo de execução é chamado de one-shot, porque o agente recebe uma única instrução e entrega o resultado completo sem necessidade de intervenções intermediárias.
Cameron Bernhardt, Engineering Manager na Stripe, comentou em uma publicação no LinkedIn que os Minions evoluíram de um conceito para a geração de mais de mil pull requests por semana, ressaltando que todo o código é revisado por humanos, mas que os agentes estão produzindo mudanças de ponta a ponta com cada vez mais autonomia.
É importante entender também que os Minions não foram criados para substituir engenheiros, mas para absorver a parte mais mecânica e repetitiva do trabalho deles. Dentro de uma empresa do tamanho da Stripe, com uma base de código massiva e centenas de engenheiros trabalhando em paralelo, existe uma quantidade enorme de tarefas que, apesar de necessárias, consomem tempo e energia cognitiva sem necessariamente exigir criatividade ou julgamento humano. São exatamente essas tarefas que os agentes assumiram, liberando os engenheiros para pensar em problemas mais complexos, arquitetura, segurança e experiência do usuário.
De onde vieram os Minions: a origem no projeto Goose
Os Minions não surgiram do zero. O sistema evoluiu a partir de um fork interno do Goose, que é um dos primeiros agentes de codificação amplamente utilizados e que foi desenvolvido pela Block. A equipe de engenharia da Stripe pegou essa base, adaptou para a infraestrutura interna de LLMs da empresa e refinou o sistema para atender aos requisitos específicos dos Minions.
Enquanto isso, ferramentas interativas como o Cursor e o Claude Code continuam sendo usadas dentro da Stripe para fluxos de trabalho que ainda exigem supervisão humana direta. Ou seja, os Minions não substituíram essas ferramentas, mas ocuparam um espaço complementar no ecossistema de desenvolvimento de software da empresa, cuidando das tarefas que podem rodar de forma completamente autônoma.
Essa decisão de partir de uma base existente em vez de construir tudo do zero mostra uma maturidade interessante da equipe. Em vez de reinventar a roda, eles aproveitaram o que já funcionava e investiram a energia no que realmente diferenciava a solução: a integração profunda com o ambiente interno da Stripe, incluindo sistemas de CI/CD, repositórios proprietários e padrões de código específicos da empresa.
Como os agentes autônomos geram pull requests na prática
O processo começa com a identificação de uma tarefa. E aqui está um dos detalhes mais legais do sistema: essa tarefa pode vir de diversas fontes. Um engenheiro pode disparar um Minion diretamente por uma mensagem no Slack, ou a tarefa pode se originar de um relatório de bug, de uma feature request ou de qualquer outra fonte que descreva o que precisa ser feito. Essa flexibilidade na entrada de dados torna o sistema muito mais acessível e integrado ao fluxo de trabalho do dia a dia.
A partir daí, o agente autônomo acessa o repositório, analisa o contexto ao redor do problema e começa a planejar a solução. Esse planejamento envolve entender quais arquivos precisam ser modificados, quais dependências existem, quais padrões de código são utilizados na base existente e como a mudança proposta vai se encaixar sem quebrar nada. Esse nível de raciocínio contextual é o que torna os modelos de linguagem modernos tão poderosos para esse tipo de aplicação.
Depois que o plano está definido, o agente executa as modificações. Ele escreve o código, cria ou atualiza testes automatizados quando necessário, ajusta documentação se for o caso e organiza tudo dentro de um pull request bem estruturado. Esse PR não chega de qualquer jeito para o time: ele vem com uma descrição clara do que foi feito, por que foi feito e quais foram as decisões tomadas ao longo do caminho. Isso facilita muito o trabalho do engenheiro que vai revisar, porque ele não precisa deduzir as intenções por trás das mudanças.
O conceito de blueprints: a receita por trás da autonomia
Um dos elementos mais importantes da arquitetura dos Minions é o conceito de blueprints. Em tradução direta seriam como plantas ou projetos, mas no contexto dos Minions funcionam como workflows definidos em código que especificam como as tarefas são divididas em subtarefas.
Os engenheiros da Stripe descrevem os blueprints como uma coleção de habilidades do agente entrelaçadas com código, garantindo eficiência enquanto mantêm a adaptabilidade. Na prática, cada blueprint combina rotinas determinísticas, que são passos fixos e previsíveis, com loops flexíveis do agente, onde o LLM toma decisões baseadas no contexto. Essa mistura é o que permite que os Minions lidem tanto com tarefas padronizadas quanto com situações que exigem algum grau de adaptação.
Pense nos blueprints como receitas de bolo, mas onde algumas etapas são fixas, como preaquecer o forno, e outras dependem do julgamento do cozinheiro, como ajustar o tempero. Esse equilíbrio entre rigidez e flexibilidade é fundamental para que os agentes consigam operar de forma autônoma sem comprometer a qualidade do resultado final.
Confiabilidade garantida por CI/CD e testes automatizados
Um sistema que gera mais de mil pull requests por semana em uma empresa que processa trilhões de dólares não pode se dar ao luxo de ter falhas. Por isso, a confiabilidade dos Minions é reforçada por pipelines de CI/CD, testes automatizados e análise estática de código. Cada mudança gerada por um agente passa por esses filtros antes mesmo de chegar ao engenheiro para revisão.
Isso significa que, quando um humano senta para revisar um pull request gerado por um Minion, ele já sabe que o código compilou, que os testes passaram e que não há violações óbvias de padrão. Esse filtro prévio reduz significativamente o tempo de revisão e aumenta a confiança no processo como um todo.
Os engenheiros da Stripe também notaram que os Minions performam melhor em tarefas bem definidas, como ajustes de configuração, atualizações de dependências e refatorações pontuais. Isso faz sentido, porque essas são exatamente as tarefas onde os critérios de sucesso são mais claros e mensuráveis, facilitando tanto a execução pelo agente quanto a validação pelo humano.
O papel dos modelos de linguagem nessa equação
Os modelos de linguagem são o coração de todo esse sistema. Sem eles, os Minions seriam apenas scripts de automação tradicionais, limitados a tarefas muito bem definidas e incapazes de lidar com qualquer variação ou ambiguidade. O que os LLMs trazem para a mesa é a capacidade de compreender contexto em linguagem natural e em código ao mesmo tempo, fazer inferências sobre o que precisa ser feito com base em descrições vagas ou incompletas, e adaptar a solução ao estilo e às convenções específicas de uma base de código particular.
A Stripe não revelou publicamente qual modelo ou quais modelos específicos estão por trás dos Minions, mas o comportamento descrito é consistente com o que os modelos de linguagem mais avançados disponíveis hoje são capazes de fazer. O uso de técnicas como recuperação aumentada por contexto, onde o agente busca informações relevantes dentro do repositório antes de agir, e encadeamento de raciocínio, onde o modelo divide o problema em etapas menores antes de resolver cada uma, são parte fundamental de como esses agentes conseguem entregar resultados coerentes em uma base de código tão grande e complexa quanto a da Stripe.
Outro ponto relevante é a capacidade de aprendizado contínuo que pode ser incorporada a esses sistemas. À medida que os engenheiros revisam os pull requests gerados pelos agentes e fazem correções ou sugestões, esse feedback pode ser usado para ajustar o comportamento dos modelos ao longo do tempo. Não necessariamente em tempo real, mas em ciclos de atualização periódicos que tornam os agentes progressivamente mais alinhados com as expectativas do time. Isso cria um loop de melhoria contínua que, no longo prazo, tende a aumentar tanto a qualidade quanto a autonomia dos agentes dentro do fluxo de desenvolvimento de software.
O que isso significa para os engenheiros de software
A narrativa de que a IA vai substituir desenvolvedores é recorrente, mas o que a Stripe está mostrando na prática aponta para uma direção diferente. O que está acontecendo ali é uma redistribuição de responsabilidades, não uma eliminação de funções. Os engenheiros continuam sendo peças centrais do processo, mas o tipo de trabalho que eles fazem mudou. Em vez de gastar horas escrevendo código para tarefas rotineiras de manutenção, atualização de dependências, refatoração padronizada ou correções simples de bugs, eles agora dedicam esse tempo para revisar o que os agentes autônomos produziram e tomar decisões sobre o que vai ou não para produção.
Esse modelo de trabalho exige um conjunto de habilidades um pouco diferente do que era valorizado antes. Saber escrever código com velocidade ainda importa, mas passa a ser quase secundário em relação à capacidade de ler código criticamente, identificar falhas de lógica, avaliar riscos de segurança e entender o impacto sistêmico de uma mudança. Em outras palavras, as habilidades de revisão e julgamento ganham protagonismo. Engenheiros que desenvolvem uma boa capacidade de trabalhar em parceria com agentes, sabendo como orientá-los, avaliá-los e corrigi-los, tendem a se tornar muito mais produtivos do que aqueles que resistem a esse novo fluxo.
Receba o melhor conteúdo de inovação em seu e-mail
Todas as notícias, dicas, tendências e recursos que você procura entregues na sua caixa de entrada.
Ao assinar a newsletter, você concorda em receber comunicações da Método Viral. A gente se compromete a sempre proteger e respeitar sua privacidade.
Além disso, há um impacto claro na velocidade de entrega de projetos. Com os agentes absorvendo o volume de tarefas repetitivas, os times conseguem avançar em múltiplas frentes ao mesmo tempo sem precisar aumentar o headcount proporcionalmente. Para empresas que operam em escala global e precisam manter sistemas críticos funcionando com altíssima disponibilidade, como é o caso da Stripe, essa capacidade de escalar o desenvolvimento de software sem inflar o time é uma vantagem competitiva concreta e mensurável.
Confiabilidade em um ambiente de alto risco
Um detalhe que não pode passar despercebido é o contexto em que os Minions operam. O código gerenciado por esses agentes suporta mais de 1 trilhão de dólares em volume anual de pagamentos e funciona em um ecossistema com dependências complexas envolvendo instituições financeiras, frameworks regulatórios e obrigações de compliance. Isso não é um projeto paralelo ou um experimento de laboratório. É produção real, em uma das infraestruturas de pagamentos mais críticas do mundo.
Esse contexto eleva o nível de exigência sobre a qualidade do código gerado pelos agentes. Qualquer erro, por menor que seja, pode ter consequências financeiras reais. Por isso, a combinação de revisão humana obrigatória com validação automatizada por pipelines de CI/CD e testes cria uma rede de segurança robusta que permite que os Minions operem com velocidade sem comprometer a integridade do sistema.
A confiabilidade e a corretude do código gerado permanecem no centro de toda a estratégia de deploy dos agentes autônomos nessa escala, e esse é um ponto que a equipe da Stripe faz questão de reforçar em suas comunicações sobre o projeto.
Uma tendência que vai muito além da Stripe
O sistema dos Minions reflete uma tendência mais ampla no desenvolvimento de software orientado por agentes, onde agentes baseados em LLMs são integrados de forma profunda aos ambientes de desenvolvimento, sistemas de controle de versão e pipelines de CI/CD para produzir código de qualidade de produção com supervisão mínima.
A Stripe não é a única empresa explorando essa direção, mas ela está entre as que estão fazendo isso na maior escala e com maior transparência sobre os resultados. O volume de mais de 1.300 pull requests semanais gerados por agentes é um dado que o mercado inteiro está olhando com atenção, porque ele prova que essa abordagem funciona em produção, dentro de uma empresa que não pode se dar ao luxo de ter instabilidade em seu sistema. A experiência da Stripe sugere que agentes autônomos de codificação podem aumentar significativamente a produtividade dos desenvolvedores mantendo controles rigorosos de qualidade.
Para times menores e startups, a lição mais valiosa talvez não seja replicar exatamente o que a Stripe fez, mas entender o princípio por trás da estratégia: identificar quais tarefas dentro do fluxo de desenvolvimento de software são repetitivas, bem definidas e com critérios claros de sucesso, e começar a automatizá-las com o apoio de modelos de linguagem. Não precisa ser um sistema sofisticado logo de início. Até mesmo a automação de tarefas simples, como geração de testes unitários ou atualização de documentação, já libera tempo valioso para o time focar no que realmente diferencia o produto.
O futuro é colaboração entre humanos e agentes
O que fica claro olhando para o que a Stripe construiu com os Minions é que o futuro do desenvolvimento de software não é humano ou máquina. É humano e máquina, trabalhando em camadas complementares, onde cada um faz o que faz melhor. Os agentes cuidam do volume, da consistência e da velocidade. Os engenheiros cuidam do julgamento, da criatividade e da responsabilidade.
O dado de que todos os pull requests contêm zero linhas de código escritas por humanos, mas passam integralmente por revisão humana, ilustra perfeitamente esse equilíbrio. Não é automação total e descontrolada. É automação com governança, onde a máquina executa e o humano valida. Essa parceria, quando bem calibrada, tem o potencial de transformar profundamente como software é construído nos próximos anos. 🤖
