Blog

Nossas últimas novidades

Tempo de Leitura

min

A Terceira Era da Programação com IA: Como Cloud Agents Estão Reescrevendo as Regras do Desenvolvimento de Software

Cloud Agents inauguram a terceira era da programação com IA. Entenda como Cursor, Stripe, OpenAI e Anthropic estão transformando o papel do desenvolvedor em orquestrador de sistemas autônomos.

25 de março de 2026

"A terceira era não é a era em que o agente 'às vezes consegue'. É a era em que a confiabilidade sobre tarefas mais longas começa a ficar operacionalmente relevante."

Em algum momento entre 2024 e o início de 2026, algo mudou na forma como software é construído. Não foi uma mudança gradual. Foi uma mudança de categoria. E se você trabalha com tecnologia, provavelmente já sentiu os primeiros sinais sem saber exatamente como nomeá-los.

A melhor forma de entender o que aconteceu é através de uma linha do tempo que Michael Truell, CEO da Cursor, desenhou publicamente: o desenvolvimento de software com IA evoluiu em três eras distintas. A primeira foi a do autocomplete, a tecla Tab prevendo a próxima linha. A segunda foi a dos agentes síncronos, loops de prompt e resposta onde a IA gerava código, mas o humano ainda precisava guiar, esperar e revisar a cada passo. A terceira, que estamos entrando agora, é a dos Cloud Agents: agentes autônomos que operam na nuvem, assumem tarefas complexas por conta própria e trabalham por minutos, horas ou até dias com o mínimo de intervenção humana. (Cursor)

O vídeo recente de Rafael Quintanilha trouxe esse tema para o centro da conversa no Brasil, explorando em profundidade como o lançamento dos Cloud Agents do Cursor marca oficialmente essa transição. Mas a história vai muito além de uma única ferramenta. Ela envolve Stripe, OpenAI, Anthropic, dados da METR e decisões regulatórias da União Europeia. E muda, de forma concreta, o que significa ser desenvolvedor de software em 2026.

Vamos aos fatos.

As três eras, em contexto

Na primeira era, a IA era um assistente de digitação. Você escrevia código e o modelo tentava prever o que viria a seguir, uma linha por vez. Era útil, mas limitado, o equivalente a um corretor ortográfico para programadores.

Na segunda era, que é onde a maioria dos times ainda opera, a interação ficou mais rica. Ferramentas como o Claude Code, o GitHub Copilot e o próprio Cursor em modo agente permitiam conversas iterativas: você descrevia o que queria, a IA gerava código, você revisava, pedia ajustes e assim por diante. O problema é que essa dinâmica criou um novo gargalo. A IA passou a produzir código muito rápido, mas transferiu para o humano o peso exaustivo de revisar, testar e validar tudo o que era gerado. A verificação virou o verdadeiro bottleneck.

A terceira era resolve exatamente essa dor. Em vez de apenas gerar código e jogar no colo do desenvolvedor, o Cloud Agent assume a tarefa de ponta a ponta. Ele clona o repositório em uma máquina virtual isolada, instala dependências, sobe o servidor local, executa a aplicação e testa o resultado na prática. O que retorna para o desenvolvedor não é apenas um diff de código, é uma prova de execução: vídeos gravados da tela, logs do terminal, previews ao vivo e uma Pull Request pronta para revisão.

Os números da própria Cursor confirmam a velocidade dessa transição. Em março de 2025, a empresa tinha cerca de 2,5 vezes mais usuários de Tab (autocomplete) do que de agentes. Pouco mais de um ano depois, a relação se inverteu completamente: há duas vezes mais usuários de agentes do que de Tab, com um crescimento de mais de 15 vezes no uso de agentes em um único ano. (Cursor)

O caso da Stripe: milhares de PRs sem uma linha humana

Quando uma das maiores empresas de infraestrutura financeira do mundo adota uma nova forma de trabalhar, o sinal é difícil de ignorar.

A Stripe construiu internamente um sistema chamado Minions, agentes de coding "one-shot", projetados para executar tarefas de ponta a ponta. O fluxo típico começa com uma mensagem no Slack e termina em uma Pull Request que já passou em CI e está pronta para revisão humana. Esses agentes trabalham em ambientes virtuais pré-aquecidos que inicializam em cerca de 10 segundos, usando o mesmo ferramental de desenvolvimento que habilita engenheiros humanos a operar na escala da empresa. (Stripe Dev)

O resultado? Segundo a própria Stripe, mais de mil Pull Requests por semana já são produzidas por esse sistema, sem conter uma única linha escrita diretamente por humanos. Não é um experimento de laboratório. É produção real, código mergeado, rodando para milhões de usuários.

A Stripe foi além e introduziu o conceito de blueprints: workflows definidos em código que dirigem a execução do agente, mesclando rotinas determinísticas com loops agênticos mais flexíveis. Isso representa um ponto de inflexão importante: não se trata de abandonar processos estruturados, mas de movê-los para uma camada mais robusta e programável.

O que os dados dizem, incluindo o que é incômodo ouvir

Aqui é onde a honestidade intelectual importa. A terceira era não é sinônimo de produtividade automática.

A METR, organização independente de avaliação de capacidades de IA, conduziu um experimento controlado com desenvolvedores experientes trabalhando em seus próprios repositórios open source. O resultado surpreendeu: com as ferramentas de IA disponíveis no início de 2025, o tempo de conclusão das tarefas aumentou em 19%. A mesma organização também alertou que muitos PRs que "passam" em benchmarks como o SWE-bench não seriam necessariamente aprovados em produção real. (METR)

Esse dado não invalida a terceira era, ele a contextualiza. A tecnologia está avançando rápido, mas o ganho real depende do sistema ao redor dela: ambiente, testes, documentação, ferramental, processos. É exatamente por isso que entender as lições dessa nova fase é tão importante.

Fora da engenharia de software, a pressão por autonomia já virou tema executivo. A IBM relatou ter levado IA agêntica a 270 mil funcionários, estimando um impacto de produtividade de US$ 4,5 bilhões. A Capgemini reportou que o uso de agentes e sistemas multiagentes subiu de 10% em 2024 para 21% em 2025, com organizações em estágio de implantação reportando ROI médio de 1,7x. Não são números específicos de coding agents, mas mostram que a discussão já saiu do laboratório e entrou no orçamento. (IBM)

1. O salto real não é "escrever código", é ampliar o horizonte de autonomia

A melhor forma de entender essa nova fase não é pensar em inteligência pontual, mas em horizonte de tarefa: por quanto tempo um agente consegue permanecer coerente, seguir o objetivo, verificar o próprio trabalho e se recuperar de erros sem perder o fio.

A OpenAI demonstrou isso de forma impressionante. Em fevereiro de 2026, a empresa relatou um experimento em que o Codex recebeu um repositório vazio, uma especificação e autonomia total para construir uma ferramenta de design. O agente rodou por cerca de 25 horas ininterruptas, consumiu aproximadamente 13 milhões de tokens e gerou algo em torno de 30 mil linhas de código, mantendo aderência à especificação, executando verificações e corrigindo falhas ao longo do caminho. (OpenAI Developers)

A METR oferece o enquadramento mais útil para medir essa evolução: o horizonte de tarefa, o comprimento das tarefas que agentes conseguem completar com determinada confiabilidade, vem dobrando a cada cerca de sete meses. Mas há um detalhe crucial: os horizontes com 80% de confiabilidade são muito menores do que os de 50%. Em outras palavras, "conseguir às vezes" é diferente de "funcionar de forma operacionalmente confiável". (METR)

A lição prática: equipes que ainda medem IA apenas por qualidade de autocomplete ou brilho de demo estão olhando para o indicador errado. O novo benchmark interno não é "quantas linhas a IA sugere", mas por quanto tempo o agente consegue operar de forma autônoma e confiável.

2. O loop de chat está cedendo espaço para execução assíncrona com artefatos revisáveis

Na segunda era, o humano guiava o agente quase passo a passo. Isso produziu bons resultados, mas preservou um gargalo: atenção humana contínua. A terceira era rompe isso ao trocar conversas longas por execução assíncrona com evidências de trabalho.

Na prática demonstrada no vídeo de Rafael Quintanilha, o Cloud Agent do Cursor recebeu um print de tela apontando um erro de alinhamento no layout e trabalhou sozinho por cerca de 10 a 17 minutos. Dividiu a interface corretamente em colunas e gravou um vídeo provando a resolução do problema. Sem intervenção humana durante a execução.

A Cursor é explícita sobre a mudança: agentes síncronos exigem o desenvolvedor no loop o tempo todo e competem por recursos na máquina local. Cloud Agents removem essas duas restrições ao rodar em VMs próprias, iterar por horas e retornar com logs, gravações em vídeo e previews ao vivo em vez de apenas diffs. (Cursor)

A OpenAI descreve o mesmo padrão no Codex: ao concluir uma tarefa, o sistema entrega mudanças commitadas no próprio ambiente e fornece evidências verificáveis por meio de citações de logs de terminal e resultados de testes, para que o usuário consiga auditar o que foi feito sem depender de uma "caixa-preta conversacional". (OpenAI)

A Anthropic também empurra nessa direção. O Claude Code já enfatiza múltiplas tarefas em paralelo, visual diffs, preview servers, monitoramento de PRs e trabalho em diferentes superfícies, terminal, IDE, desktop e web. O produto deixa de ser um copiloto sentado ao lado do editor e passa a se parecer com uma central de despacho e revisão de trabalho agêntico. (Anthropic)

A interface dominante da programação com IA não será apenas o chat. Será a combinação entre fila de tarefas, ambientes isolados, artefatos revisáveis, CI, previews, logs e PRs. Quem continuar pensando só em prompt box vai subestimar a transformação.

3. Prompt não escala; scaffolding escala

Talvez a maior lição compartilhada entre Cursor, Stripe, OpenAI e Anthropic seja esta: o diferencial deixou de ser "escrever o prompt certo" e passou a ser desenhar o ambiente certo.

A OpenAI chega a essa conclusão no texto sobre "harness engineering". A empresa relata que, ao construir um produto inteiro com uma equipe pequena apoiada por Codex, o trabalho humano deixou de ser escrever código e passou a ser desenhar sistemas, scaffolding e feedback loops. O grande problema não era a incapacidade do agente, mas um ambiente subespecificado: faltavam ferramentas, abstrações, estrutura interna e mecanismos de feedback que tornassem o objetivo legível e executável. Em cinco meses, o repositório chegou à ordem de um milhão de linhas de código e cerca de 1.500 PRs com uma equipe muito enxuta, mas o ganho veio do harness, não de "prompts heroicos". (OpenAI)

A Anthropic reforça isso de forma quase brutal no relato sobre a construção de um compilador C com um time de Claudes operando em paralelo. O autor afirma que a maior parte do esforço foi para desenhar testes, ambiente e feedback, e que o verificador precisava ser quase perfeito. Caso contrário, o agente resolveria o problema errado. É uma formulação elegante para algo que muitos times ainda subestimam: autonomia sem verificação robusta só produz velocidade na direção errada. (Anthropic)

Isso também explica por que arquivos como AGENTS.md e CLAUDE.md ganharam tanta importância. No Codex, AGENTS.md funciona como uma camada de instruções persistentes e hierárquicas que orienta o agente antes do trabalho começar. No Claude Code, CLAUDE.md, memórias automáticas, comandos customizados e hooks cumprem papel semelhante: transformar cultura, padrões e checklists em contexto operacional reutilizável. (OpenAI Developers)

A lição é direta: o "moat" da terceira era não está só no modelo. Está no harness. Times que só compram licença vão experimentar. Times que codificam processo, testes, ferramentas, instruções e critérios de aceite vão escalar.

4. O agente só trabalha bem no que consegue ver, testar e verificar

Uma das passagens mais importantes publicadas pela OpenAI este ano funciona quase como um princípio operacional: do ponto de vista do agente, aquilo que ele não consegue acessar em contexto simplesmente não existe. Google Docs, mensagens no Slack, conhecimento tácito, nada disso era visível para o Codex. Para que virassem contexto útil, precisavam ser convertidos em artefatos versionados dentro do repositório: documentação, esquemas, planos executáveis, regras e mapas de arquitetura. (OpenAI)

Esse aprendizado levou a OpenAI a tornar a aplicação e a observabilidade "legíveis" para o agente. O Codex passou a usar Chrome DevTools para inspecionar e dirigir a interface, além de trabalhar com logs, métricas e traces em um stack local efêmero. Com isso, pedidos do tipo "garanta que este fluxo crítico fique abaixo de 800ms" deixam de ser apenas intenção textual e passam a ser algo que o agente pode medir, testar e iterar.

A Anthropic empurra na mesma direção com o MCP (Model Context Protocol), um padrão aberto para conectar aplicações de IA a fontes de dados e ferramentas externas de forma segura e bidirecional. No Claude Code, isso aparece de forma prática: o agente pode ler design docs no Google Drive, atualizar tickets no Jira, puxar dados do Slack ou usar tooling próprio da empresa via MCP. (Model Context Protocol)

No vídeo de Rafael Quintanilha, os agentes do Cursor foram equipados com integrações externas via MCP. Com o TestSprite, por exemplo, o agente conseguiu criar e executar testes end-to-end de forma completamente automatizada na nuvem, garantindo ainda mais segurança antes de gerar a Pull Request final.

A lição: a qualidade dos agentes depende menos de "mágica" e mais da capacidade da organização de transformar conhecimento disperso em superfície operacional. Não basta ter um repositório. É preciso ter um repositório, uma toolchain e uma camada de contexto que agentes consigam navegar.

5. O engenheiro não desaparece, ele sobe de camada

A narrativa preguiçosa sobre IA em software fala em substituição. A narrativa correta fala em mudança de camada de trabalho.

A Cursor descreve três traços das equipes que já trabalham nesse novo modo: os agentes escrevem quase 100% do código, os humanos passam mais tempo quebrando problemas, revisando artefatos e dando feedback, e múltiplos agentes são disparados em paralelo em vez de um único agente ser "carregado no colo" até o fim. (Cursor)

A OpenAI conta história semelhante. Em seu repositório gerado por agentes, humanos deixaram de contribuir código diretamente, mas não saíram do processo. Eles priorizam trabalho, traduzem feedback em critérios de aceite, validam resultados e, quando o agente falha, tratam isso como sintoma de algo ausente no sistema: ferramenta, guardrail, documentação, regra, linter ou estrutura de contexto. O trabalho humano migra da execução para a engenharia do sistema que torna a execução confiável. (OpenAI)

Essa ascensão de camada vem com uma cobrança dura. A própria Cursor alerta que, em escala industrial, um teste flaky ou um ambiente quebrado que um desenvolvedor humano contornaria localmente passa a interromper todos os runs de agentes. A OpenAI também é explícita: a autonomia end-to-end dependeu fortemente da estrutura e do tooling específicos daquele repositório e não deveria ser assumida como generalizável sem investimento semelhante.

Há ainda o eixo regulatório. O AI Act da União Europeia entrou em vigor em agosto de 2024 e suas regras principais começam a valer em agosto de 2026. Mesmo para empresas fora da UE, a direção é inequívoca: quanto mais agentes escrevem código, manipulam dados e acionam sistemas, maior a necessidade de trilha de auditoria, limites de permissão, revisão humana, rastreabilidade e padrões abertos de integração. (European Commission)

A terceira era não reduz a importância da liderança técnica. Ela aumenta. A organização que vence não é a que "solta" agentes, é a que sabe orquestrá-los com critérios, evidências e limites claros.

Como começar sem cair no teatro de demos

A forma mais segura de entrar nessa transição não é tentar automatizar toda a engenharia de uma vez. É começar por um fluxo estreito, verificável e repetitivo.

Escolha tarefas onde o ganho é claro e a verificação é objetiva. Escrever testes para módulos sem cobertura, corrigir lint, resolver conflitos de merge, atualizar dependências, gerar release notes, pequenos refactors. É exatamente esse tipo de trabalho que aparece tanto na documentação do Claude Code quanto nos relatos da Stripe sobre onde agentes performam melhor.

Trate o repositório como interface para agentes. Crie e mantenha arquivos de instrução como AGENTS.md ou CLAUDE.md, documente decisões de arquitetura, comandos de build, critérios de revisão e convenções. O objetivo não é "explicar tudo", mas dar ao agente um mapa confiável do que importa.

Endureça seu ambiente antes de exigir autonomia. Testes frágeis, builds não reprodutíveis e pouca observabilidade não são só problemas de DevEx, são sabotadores diretos de agentes. Cursor, OpenAI e Anthropic convergem nesse ponto.

Comece com agentes assíncronos, mas mantenha revisão humana obrigatória. Stripe, Cursor e OpenAI convergem para o mesmo padrão: autonomia forte na execução, revisão humana na saída.

Meça o que realmente importa. Tempo de ciclo, taxa de merge, retrabalho, falhas escapadas, tempo de review e número de intervenções humanas por tarefa. A tentação de medir só linhas geradas ou consumo de tokens produz teatro, não produtividade. A própria divergência entre benchmarks fortes e resultados mistos no mundo real já demonstrou isso.

Conclusão: a fábrica importa mais do que a ferramenta

A terceira era da programação com IA não começa quando um modelo escreve um arquivo impressionante. Ela começa quando a engenharia deixa de tratar IA como autocomplete glorificado e passa a tratá-la como força de trabalho operacional dentro de um sistema desenhado para autonomia confiável.

É por isso que Cursor e Stripe são sinais tão importantes. Eles não estão dizendo apenas que "a IA programa". Estão mostrando algo mais profundo: que o trabalho de software está sendo reempacotado em torno de objetivos, artefatos, harnesses, ambientes isolados, verificação automática e revisão humana em camadas mais altas de abstração.

A pergunta certa, daqui para frente, não é se sua empresa vai usar IA para programar. A pergunta certa é: sua engenharia vai continuar usando IA como ferramenta reativa, ou vai construir a infraestrutura, técnica, cultural e operacional, que permite agentes realmente úteis?

Sua empresa está nesse ponto de transição?

A X-Apps ajuda a desenhar o passo da experimentação com copilotos para workflows agênticos auditáveis, escaláveis e conectados ao seu processo real de engenharia. Solicite um orçamento.

Nome

Sobrenome

Telefone