Principais destaques
- Agentes no comando: o Antigravity troca o modelo de IA na lateral por um ambiente em que agentes planejam, executam tarefas e verificam resultados.
- Prova do trabalho: os chamados Artifacts transformam planos, screenshots e gravações do navegador em recibos que humanos podem revisar rapidamente.
- Autonomia tem preço: ataques de prompt injection e limites de uso mostraram que agentes mais independentes também exigem permissões, revisão e isolamento.
Um agente de IA que escreve uma funcionalidade, abre o terminal, testa o resultado no navegador, encontra um erro e corrige tudo sozinho já não parece ficção científica.
É exatamente essa a proposta do Google Antigravity.
A plataforma foi criada para uma mudança simples, mas importante: em vez de a inteligência artificial apenas sugerir código, ela recebe um objetivo e tenta levar a tarefa até o fim.
Só que existe um detalhe.
Quanto mais a IA consegue fazer sem pedir ajuda, maior também é o estrago potencial quando ela entende algo errado, acessa o lugar errado ou segue uma instrução maliciosa.
E 2026 deixou essa conta bem clara.
O Antigravity quer mudar a pergunta 🎯
A maioria das ferramentas de programação com IA vende uma promessa conhecida: escrever código mais rápido. O Antigravity parte de outra lógica.
A pergunta deixa de ser “como a IA pode me ajudar a programar?” e passa a ser “o que eu quero que ela entregue?”.
O desenvolvedor fornece o objetivo. O agente planeja, altera arquivos, executa ferramentas, testa o resultado e tenta verificar se aquilo realmente funciona.
🔎 O ponto central: a plataforma foi desenhada para trabalhar em cima do resultado final, e não apenas para acelerar cada linha digitada por uma pessoa.
Esse modelo aproxima o desenvolvimento de software de uma delegação de tarefas. É menos parecido com um copiloto sugerindo uma curva e mais com alguém recebendo uma rota inteira para executar.
De onde veio essa ideia? 🧩
O Google anunciou o Antigravity em 18 de novembro de 2025, junto com o Gemini 3, colocando a plataforma em prévia pública no mesmo dia.
A ferramenta roda em macOS, Windows e Linux e, durante a prévia, foi disponibilizada gratuitamente.
Por baixo da experiência familiar existe uma versão bastante modificada do Visual Studio Code.
Também houve discussão pública sobre a linhagem do projeto, incluindo a possibilidade de uma relação com o Windsurf, que por sua vez também tem origem no ecossistema do VS Code.
Para quem já usa editores modernos de programação, portanto, a interface não parece um alienígena.
A diferença está menos na aparência e mais no que acontece depois que a tarefa é entregue.
Planejar, executar e verificar. Nessa ordem 🤖
O ciclo básico do Antigravity pode ser resumido em três movimentos.
1️⃣ Planejar: o agente define o que precisa ser feito e organiza as etapas.
2️⃣ Executar: arquivos são modificados e ferramentas são acionadas para colocar o plano em prática.
3️⃣ Verificar: o agente testa o resultado e procura sinais de que a tarefa realmente funcionou.
O terceiro passo é particularmente importante.
Um código que parece correto pode quebrar justamente na parte que ninguém olhou.
Imagine um agente criando um novo componente. Ele pode alterar os arquivos, iniciar a aplicação pelo terminal, abrir a página no navegador e conferir se o componente aparece corretamente antes de declarar a tarefa concluída.
É aí que a proposta deixa de ser apenas “gerar código”. O agente está tentando fechar o ciclo.
💡 A grande mudança é esta: a IA não entrega apenas uma sugestão. Ela tenta entregar uma tarefa concluída e verificável.
Duas telas para dois jeitos de trabalhar 🖥️
O Antigravity organiza essa experiência em duas superfícies principais.
Editor View: ainda dá para colocar a mão na massa ✍️
A primeira é o Editor View, que funciona como um ambiente de desenvolvimento familiar.
Há preenchimento automático, comandos inline e interação direta com o código.
É o modo síncrono. O desenvolvedor conduz o trabalho enquanto a IA ajuda.
Quem já conhece VS Code ou ferramentas como Cursor encontra uma experiência relativamente familiar aqui.
Agent Manager: o painel de controle 🕹️
A segunda superfície é o Agent Manager.
Aqui, a lógica muda. Em vez de editar tudo diretamente, o usuário delega tarefas, acompanha o progresso e revisa os resultados.
É especialmente útil quando vários agentes podem trabalhar em paralelo.
Um agente pode estar lidando com uma parte do projeto enquanto outro executa uma tarefa diferente.
A consequência prática é interessante: a pessoa deixa de acompanhar cada comando e passa a supervisionar missões.
O recibo que a IA deixa para trás 🧾
Delegar trabalho cria um problema óbvio.
Como saber se o agente fez o que deveria?
O Antigravity tenta resolver isso com os Artifacts.
São registros estruturados produzidos durante o trabalho, incluindo:
• planos de implementação;
• listas de tarefas;
• screenshots;
• passo a passo de verificação;
• gravações da interação com o navegador.
Isso muda bastante a experiência de revisão.
Em vez de alguém precisar atravessar uma montanha de logs para descobrir o que aconteceu, o agente deixa uma espécie de recibo do trabalho realizado.
🧠 A sacada: confiança não precisa significar acreditar na IA. Pode significar conseguir verificar rapidamente o que ela fez.
O sistema permite ainda que um revisor deixe comentários diretamente em um Artifact. O agente pode incorporar esse feedback sem necessariamente reiniciar todo o processo.
Para ambientes em que humanos precisam supervisionar agentes, essa ideia é particularmente relevante.
Autonomia não é botão liga/desliga ⚙️
Quanto mais poder um agente recebe, maior a importância das permissões.
O Antigravity trata autonomia como um controle graduável.
Na execução de comandos pelo terminal, há três modos:
| Modo | Comportamento |
|---|---|
| Off | Não executa comandos automaticamente, salvo os permitidos |
| Auto | O agente decide quando executar e pede autorização quando necessário |
| Turbo | Executa comandos automaticamente, exceto os bloqueados |
Há também uma política de revisão dos Artifacts.
Ela pode variar de um modelo em que o agente segue sem pedir confirmação até outro em que uma revisão humana é sempre solicitada.
Isso cria uma espécie de acelerador de confiança.
No começo, uma equipe pode restringir bastante o agente. Conforme conhece seu comportamento, pode liberar mais ações.
Ou fazer o contrário quando a tarefa envolve dados sensíveis.
E quando a IA abre o navegador? 🌐
O Antigravity também consegue controlar o Chrome.
Um subagente de navegador pode abrir páginas, navegar, extrair informações, automatizar ações e capturar screenshots ou gravações para comprovar o resultado.
Mas existe uma barreira importante.
A navegação ocorre em um navegador isolado e administrado pelo próprio Antigravity, separado da navegação normal do usuário.
A lista inicial de endereços permitidos também começa restrita, com localhost entre os destinos autorizados.
Quando o agente tenta acessar um endereço fora dessa lista, aparece uma solicitação de permissão. O usuário pode autorizar aquele domínio permanentemente.
🛡️ A lógica é simples: o comportamento seguro vem primeiro. Expandir o alcance exige uma decisão explícita.
E isso importa porque uma IA que consegue navegar também consegue encontrar conteúdo hostil.
Antigravity 2.0 levou a ideia para fora do editor 🚀
Em 19 de maio de 2026, durante o Google I/O, o Google apresentou o Antigravity 2.0.
A evolução ampliou a plataforma para além de um aplicativo de programação.
O pacote passou a incluir:
1️⃣ Aplicativo desktop: uma casa central para coordenar agentes, executar tarefas em paralelo, criar subagentes dinamicamente e programar automações.
2️⃣ CLI: uma interface diretamente no terminal para quem prefere trabalhar sem abrir uma interface gráfica.
3️⃣ SDK: acesso programático ao mesmo harness de agentes usado pela plataforma, permitindo criar comportamentos personalizados e hospedá-los em infraestrutura própria.
4️⃣ Managed Agents na Gemini API: uma chamada de API pode iniciar um agente capaz de raciocinar, usar ferramentas e executar código em um ambiente Linux isolado.
A versão 2.0 também colocou o Gemini 3.5 Flash como modelo padrão.
Segundo o Google, ele supera o Gemini 3.1 Pro em quase todos os benchmarks e é cerca de quatro vezes mais rápido do que outros modelos de fronteira.
Para agentes, velocidade não é mero detalhe.
Uma resposta mais rápida importa menos quando a IA apenas escreve um parágrafo. Quando ela executa dezenas de etapas, cada segundo começa a entrar na conta.
A parte que nenhum demo consegue esconder 🔐
A autonomia também abriu uma porta para problemas de segurança.
Um agente que lê arquivos, acessa páginas, executa comandos e interpreta instruções externas pode ser manipulado por esse próprio conteúdo.
Esse é o território do prompt injection.
O problema é estrutural: um modelo de linguagem pode ter dificuldade para distinguir uma instrução legítima do usuário de uma instrução maliciosa escondida em uma página ou documento que ele acabou de ler.
Pesquisadores demonstraram ataques de injeção indireta capazes de induzir agentes a roubar dados ou executar ações não autorizadas.
Em um dos casos citados no material, a Pillar Security encontrou uma vulnerabilidade relacionada à ferramenta de busca de arquivos do Antigravity que permitia contornar o sandbox do Strict Mode e chegar à execução de código. O Google corrigiu a falha no fim de fevereiro de 2026, após uma divulgação responsável feita em janeiro.
O alerta vai além de uma vulnerabilidade específica.
🚨 Quando o agente recebe instruções de conteúdo externo, a revisão humana deixa de ser um detalhe de interface e passa a fazer parte do modelo de segurança.
Esse é provavelmente um dos pontos mais importantes de toda a experiência do Antigravity.
Um agente mais poderoso não é automaticamente um agente mais seguro.
Antigravity, Cursor ou Claude Code? 🔄
O mercado de programação com agentes já reúne nomes como Antigravity, Cursor, Claude Code e Codex.
A diferença entre eles não está apenas no modelo utilizado.
| Dimensão | Google Antigravity | Cursor | Claude Code |
|---|---|---|---|
| Superfície principal | Desktop e Agent Manager | Editor baseado em VS Code | Terminal |
| Foco | Trabalho paralelo e assíncrono | Desenvolvimento diário no editor | Controle via terminal |
| Modelo padrão | Gemini 3.5 Flash | Variável | Claude |
| Verificação | Artifacts, screenshots e gravações | Diffs e revisão no editor | Aprovação antes de alterações |
| Preço de entrada em 2026 | Prévia gratuita, depois plano Pro | Cerca de US$ 20/mês mais uso | Cerca de US$ 20/mês mais uso |
Na prática, as diferenças aparecem no fluxo de trabalho.
Quem prefere permanecer dentro de um editor tende a valorizar uma experiência diferente de quem quer abrir vários agentes e supervisioná-los de um painel.
E quem vive no terminal tem outra relação com a ferramenta. Por isso, comparar apenas benchmarks conta uma parte pequena da história.
O problema que apareceu na conta 💸
O Antigravity começou sua prévia com acesso gratuito e limites considerados generosos para os modelos Gemini.
Ao longo de 2026, porém, o acesso passou a ser associado aos planos de IA do Google.
O plano Pro ficou na faixa de US$ 20 por mês, enquanto níveis mais altos passaram a oferecer limites maiores. No I/O, o Google também apresentou um plano Ultra de US$ 100 mensais com uma franquia de uso significativamente maior para o Antigravity.
Os números podem mudar, e o próprio material recomenda conferir os valores atuais antes de tomar uma decisão baseada neles.
Mas o ponto mais interessante não é o preço. É o limite.
Usuários reclamaram em 2026 de mudanças nas cotas, incluindo relatos de limites semanais que interrompiam o trabalho até que créditos adicionais fossem comprados ou o plano fosse atualizado.
📉 A consequência operacional: agentes consomem capacidade porque realmente executam trabalho. Se o limite chega no meio de uma tarefa, o problema deixa de ser apenas uma questão de IA e vira um problema de infraestrutura.
Throttling, fallback e degradação controlada passam a fazer parte da arquitetura.
O que empresas podem copiar dessa experiência? 🏢
A lição do Antigravity não precisa ficar restrita ao desenvolvimento de software.
Os mesmos princípios aparecem quando agentes são colocados diante de clientes, operações, dados internos ou sistemas corporativos.
São três controles especialmente importantes.
• Permissão: começar pelo menor nível de acesso necessário e expandir apenas quando houver justificativa.
• Revisão: exigir intervenção humana nas ações realmente consequenciais e oferecer registros fáceis de auditar.
• Isolamento: impedir que um erro ou comprometimento em uma etapa dê acesso automático ao restante do ambiente.
É uma mudança de mentalidade.
A pergunta não é mais simplesmente “a IA consegue fazer isso?”.
É “até onde queremos que ela possa ir sem alguém olhar?”.
O paralelo com atendimento ao cliente 🤝
É nesse ponto que o modelo do Antigravity conversa com aplicações de agentes fora do código.
Em atendimento e operações, por exemplo, um agente pode consultar contexto de uma conta, preparar uma resposta, identificar um risco e, em determinados cenários, executar uma ação.
O mesmo princípio continua valendo.
A IA pode fazer mais quando recebe permissões específicas, quando suas ações podem ser verificadas e quando existe isolamento suficiente para conter um eventual problema.
No material de referência, essa filosofia aparece na proposta da Helply, que mantém humanos no controle dos rascunhos e usa agentes para executar ações dentro dos limites definidos.
O modelo também inclui registro das decisões tomadas pela IA.
Há ainda uma estrutura de cobrança baseada no resultado: US$ 0,25 por resposta criada, US$ 0,50 por resolução autônoma e US$ 2,99 por um sinal de receita, como risco de churn ou oportunidade de upsell.
Se não houver resultado, não há cobrança, segundo a proposta apresentada.
O verdadeiro produto pode não ser o modelo 🧠
O Antigravity ajuda a mostrar uma mudança importante no mercado de IA.
À medida que diferentes modelos se aproximam em capacidade, o diferencial pode migrar para o que existe ao redor deles.
- Permissões.
- Ferramentas.
- Ambientes isolados.
- Aprovações.
- Registros.
- Verificação.
E, principalmente, uma interface que permita ao humano saber quando deve intervir.
É uma evolução de “IA que responde” para “IA que trabalha”.
Mas também é uma evolução de “confie na resposta” para “prove o que foi feito”.
No fim, o Antigravity começou como uma ferramenta para programadores. Em 2026, a proposta já aponta para algo maior: agentes capazes de operar sistemas inteiros sob supervisão humana.
A promessa parece uma mudança de carro: em vez de dirigir cada metro, você define o destino e acompanha o percurso.
Só que, nesse carro, ainda importa muito saber quem está segurando o volante, quais estradas foram liberadas e o que acontece se o navegador mandar entrar em uma rua errada.
A próxima etapa dos agentes provavelmente será menos sobre provar que eles conseguem agir.
E mais sobre decidir quando, onde e sob quais condições eles devem agir sozinhos.
E se você simplesmente dissesse: “construa o aplicativo”? ✈️
É aqui que o Antigravity fica mais fácil de entender.
Imagine um pedido como: “crie um aplicativo de rastreamento de voos com atualizações em tempo real e sistema de reservas”.
Em um fluxo tradicional, isso significa transformar a ideia em dezenas de pequenas tarefas.
No modelo agent-first, o agente pode decompor o objetivo em partes como interface, API, testes e implantação.
O Agent Manager coordena esse trabalho enquanto os agentes atuam nas diferentes superfícies da ferramenta.
🧪 Depois vem a prova: o resultado pode incluir uma lista de tarefas, um plano de implementação e evidências dos testes realizados.
A diferença é parecida com contratar alguém para montar um móvel.
Uma ferramenta convencional entrega as instruções e talvez segure algumas peças. Um agente tenta montar o móvel, testar se as gavetas abrem e mostrar o que fez.
Um checkout completo em vez de um botãozinho 🛒
Outro exemplo apresentado no material é um fluxo de checkout de comércio eletrônico.
O pedido seria criar um sistema com carrinho, autenticação e integração com Stripe.
A partir daí, o agente poderia:
1️⃣ Construir a interface: criar os componentes React necessários.
2️⃣ Montar a API: configurar uma API Express e a integração de pagamento.
3️⃣ Testar o percurso: adicionar produtos, iniciar o checkout e verificar o resultado no navegador.
4️⃣ Preparar a entrega: gerar os elementos necessários para implantação.
O exemplo citado afirma que uma tarefa desse tipo poderia cair de cerca de duas horas para poucos minutos.
Há, porém, uma ressalva importante.
Esses tempos são exemplos apresentados pelo material de referência, não uma garantia de produtividade. O resultado real depende da complexidade do projeto, da qualidade do prompt, do ambiente, dos testes e de quantas correções o agente precisa fazer.
Isso vale também para a promessa de redução de 95% no tempo.
Uma demo que termina em quatro minutos não significa que qualquer projeto real será concluído em quatro minutos.
O que dá para fazer sem escrever uma linha? 💻
A proposta de no-code aparece justamente aqui.
O usuário pode começar com uma instrução de alto nível e deixar o agente transformar essa descrição em uma sequência de tarefas técnicas.
Mas “sem escrever código” não significa “sem precisar entender o que está acontecendo”.
Quanto maior a autonomia, mais importante fica saber avaliar o resultado.
Um desenvolvedor que não entende a arquitetura pode até conseguir gerar uma aplicação funcional. O problema aparece quando surge um bug difícil, uma falha de segurança ou uma decisão técnica que exige contexto.
💡 Menos digitação não significa menos responsabilidade.
Na verdade, para agentes autônomos, a responsabilidade muda de lugar: sai parcialmente da escrita de cada linha e vai para a definição do objetivo, das permissões e dos critérios de aprovação.
E dá para usar outros modelos? 🧠
O Antigravity foi projetado em torno dos modelos Gemini, mas o material também aponta para suporte a modelos de outros fornecedores.
A referência cita Claude e GPT-OSS entre as opções disponíveis.
Também existem alegações de integração com modelos locais e endpoints personalizados, incluindo ferramentas como Ollama e serviços de roteamento de modelos.
Esse ponto merece cuidado.
A possibilidade de trocar modelos, usar endpoints externos ou conectar modelos locais depende da implementação e das integrações efetivamente disponíveis na versão utilizada. Portanto, configurações específicas apresentadas como universais no material devem ser verificadas antes de serem reproduzidas em produção.
A ideia, porém, é relevante.
Se o agente é o produto e o modelo é uma peça do motor, trocar o motor sem reconstruir o carro inteiro pode ser uma vantagem arquitetural.
Como começar sem transformar seu computador em laboratório de risco 🛡️
Para quem está chegando agora, a recomendação mais importante não é “dê uma tarefa enorme para a IA”.
É fazer exatamente o contrário.
Comece pequeno.
Use um projeto de teste, uma branch descartável ou um ambiente isolado. Evite entregar acesso desnecessário a arquivos, credenciais, produção e serviços externos.
E mantenha confirmações para ações que possam causar consequências difíceis de reverter.
Uma configuração inicial mais conservadora pode seguir esta lógica:
1️⃣ Projeto descartável: teste o agente em algo que possa ser restaurado.
2️⃣ Permissões mínimas: libere apenas os arquivos e ferramentas necessários.
3️⃣ Revisão do plano: confira o que o agente pretende fazer antes da execução.
4️⃣ Terminal sob controle: mantenha comandos potencialmente destrutivos atrás de aprovação.
5️⃣ Teste isolado: não conecte o primeiro experimento diretamente ao ambiente de produção.
6️⃣ Verificação final: confira os Artifacts, testes e alterações antes de aceitar o resultado.
Parece burocrático.
Até o dia em que uma única linha de comando deixa de ser apenas uma linha de comando.
O episódio do comando destrutivo acende outra luz ⚠️
O material também cita relatos públicos de um incidente em que o Antigravity teria executado um comando destrutivo e apagado dados de um desenvolvedor, além de pesquisas sobre riscos envolvendo execução de comandos e exfiltração de arquivos.
Esses relatos devem ser tratados como casos documentados por fontes externas e não como comportamento inevitável da ferramenta.
O aprendizado, entretanto, é direto.
Se um agente tem permissão para executar comandos no seu computador, ele precisa ser tratado como software com capacidade operacional real.
Não é apenas um chatbot com acesso a um terminal.
E essa distinção muda completamente o cálculo de risco.
🚨 Se a IA pode executar o comando, o botão “confirmar” deixa de ser uma formalidade. Ele pode ser a última barreira entre uma automação útil e uma alteração irreversível.
O verdadeiro limite talvez seja a confiança 🔍
Existe uma tendência natural de medir agentes pela quantidade de coisas que conseguem fazer sozinhos.
Quantos arquivos alteram?
Quantas tarefas executam?
Quantos minutos economizam?
Mas existe outra métrica, menos chamativa e provavelmente mais importante: quanto trabalho humano é necessário para verificar o que eles fizeram?
É aí que os Artifacts ganham importância.
Se um agente conclui uma tarefa em cinco minutos, mas exige uma hora para alguém investigar seus logs, a automação não desapareceu, mas parte do benefício evaporou.
Se ele produz um plano claro, screenshots, gravações e evidências de teste que podem ser conferidas rapidamente, a supervisão fica mais escalável.
Essa talvez seja uma das ideias mais transferíveis do Antigravity para outras áreas.
Para onde essa arquitetura pode ir? 🚀
O Antigravity começou como uma ferramenta para desenvolvimento, mas sua arquitetura aponta para uma categoria mais ampla.
Agentes que recebem objetivos.
Agentes que usam ferramentas.
Agentes que executam tarefas em paralelo.
Agentes que deixam evidências.
E humanos que supervisionam as decisões realmente importantes.
Isso pode ser aplicado a programação, operações, suporte, pesquisa, análise de dados e outros fluxos de trabalho.
A fronteira, portanto, não é apenas entre “IA que escreve código” e “IA que escreve código melhor”.
É entre IA que produz uma resposta e IA que participa de um processo inteiro.
E quanto mais esse processo se aproxima de sistemas reais, dinheiro real e clientes reais, menos interessante fica perguntar apenas se o agente é inteligente.
A pergunta passa a ser outra: quem autorizou a ação, o que exatamente ele pôde acessar e como alguém consegue provar o que aconteceu depois?
É a mesma lógica daquela estrada imaginária do começo.
Não basta o carro saber chegar ao destino.
É preciso saber quais caminhos ele pode pegar, quando deve frear e, principalmente, quem ainda está olhando para a estrada.
Agora é a sua vez: comece com um prompt pequeno 🧪
Depois de entender a arquitetura, falta a parte mais útil para quem quer experimentar: o que exatamente escrever para o agente?
A resposta não é começar com “crie uma startup completa”.
Quanto mais autonomia você dá ao agente, mais importante é separar planejamento, execução e revisão.
Uma boa primeira experiência é pedir algo pequeno, verificável e fácil de desfazer.
Prompt 1: seu primeiro teste
Analise este projeto antes de fazer qualquer alteração.
Quero adicionar uma página /about.
Primeiro:
1. Explique brevemente a estrutura atual do projeto.
2. Identifique quais arquivos provavelmente precisarão ser alterados.
3. Crie um plano de implementação.
4. Não altere nenhum arquivo ainda.
Depois, aguarde minha aprovação.
Esse prompt testa uma característica essencial do Antigravity: separar planejamento de execução.
Você não está pedindo que o agente saia modificando o projeto imediatamente.
Está pedindo primeiro um mapa.
Se o plano fizer sentido, aí vem o segundo comando.
Prompt 2: deixe o agente executar
Aprovado.
Agora implemente o plano para a página /about.
Regras:
- Faça apenas as alterações necessárias.
- Não altere configurações de infraestrutura.
- Não instale dependências sem me informar antes.
- Execute os testes relevantes depois da implementação.
- Se encontrar um problema, tente corrigi-lo.
- No final, gere um resumo das alterações e das verificações realizadas.
Aqui começa a diferença entre um assistente de código convencional e um agente.
O objetivo não é apenas gerar um trecho de código.
É completar uma sequência:
planejar → alterar → testar → corrigir → verificar.
Quer colocar o navegador para trabalhar? 🌐
O próximo passo é pedir uma verificação visual.
Imagine que você acabou de criar uma página de login.
Em vez de olhar somente para o código, peça ao agente para abrir a aplicação e verificar o comportamento.
Prompt 3: teste no navegador
Agora valide a página de login no navegador.
Faça o seguinte:
1. Inicie a aplicação usando os comandos apropriados.
2. Abra a página de login.
3. Verifique se os principais elementos aparecem corretamente.
4. Teste a interação com os campos de usuário e senha.
5. Verifique o comportamento do botão de login.
6. Capture screenshots dos pontos relevantes.
7. Se encontrar um erro visual ou funcional, descreva o problema antes de corrigi-lo.
8. Depois da correção, repita o teste.
Ao final, apresente as evidências da verificação.
Esse é um bom momento para entender por que os Artifacts são importantes.
Você não precisa depender apenas da frase “funcionou”.
Pode conferir as evidências produzidas durante o processo.
Agora aumente o tamanho da missão ✈️
Depois de dominar tarefas pequenas, dá para experimentar um fluxo mais próximo dos exemplos apresentados no material.
Imagine um aplicativo de rastreamento de voos.
Em vez de pedir tudo de uma vez sem restrições, transforme o projeto em uma missão.
Prompt 4: construa um protótipo de flight tracker
Quero criar um protótipo de aplicativo de rastreamento de voos.
Objetivo:
Criar uma aplicação web em que o usuário possa pesquisar um voo e visualizar suas informações principais.
Antes de implementar:
1. Analise o objetivo.
2. Divida o trabalho em UI, dados/API, lógica, testes e validação.
3. Identifique dependências e riscos.
4. Crie um plano de implementação.
5. Liste os critérios que determinarão se a tarefa está concluída.
Não comece a executar ainda. Aguarde minha aprovação.
Observe a estrutura.
Você está dizendo ao agente o que quer, mas também está definindo como ele deve pensar sobre a tarefa.
Isso reduz a chance de uma missão grande virar uma sequência desorganizada de decisões.
Depois, transforme o plano em execução 🤖
Com o plano aprovado:
Prompt 5: execute em etapas
Plano aprovado.
Execute o projeto seguindo estas regras:
- Trabalhe em etapas pequenas e verificáveis.
- Após cada etapa importante, valide o resultado.
- Não faça alterações fora do escopo sem me consultar.
- Não use credenciais reais.
- Não faça deploy em produção.
- Se uma API externa for necessária, use dados simulados ou um ambiente de teste.
- Registre decisões importantes nos Artifacts.
- Gere screenshots da interface funcionando.
- Execute os testes disponíveis.
- Ao encontrar falhas, tente corrigi-las e repita a validação.
Ao final, apresente:
1. O que foi implementado.
2. O que foi testado.
3. Quais problemas foram encontrados.
4. Quais problemas permanecem.
5. O que seria necessário para colocar o projeto em produção.
Esse último bloco é especialmente importante.
🚦 “Terminei” não deveria significar simplesmente “o código foi escrito”.
Para um agente, terminar uma tarefa deveria envolver critérios verificáveis.
Quer testar vários agentes ao mesmo tempo? 🧩
É justamente aqui que entra o Agent Manager.
Um projeto maior pode ser dividido em missões independentes.
Por exemplo:
• um agente trabalha na interface;
• outro analisa a API;
• outro prepara testes;
• outro verifica a experiência no navegador.
Um prompt de coordenação poderia ser:
Prompt 6: dividir uma missão entre agentes
Quero desenvolver este projeto: [DESCREVA O PROJETO].
Divida o trabalho em tarefas que possam ser executadas em paralelo.
Para cada tarefa, informe:
- objetivo;
- arquivos envolvidos;
- dependências;
- resultado esperado;
- como será verificada.
Não permita que dois agentes alterem o mesmo arquivo simultaneamente sem necessidade.
Priorize tarefas independentes.
Antes de iniciar qualquer tarefa com risco de conflito ou alteração estrutural, solicite minha aprovação.
A ideia é simples: paralelizar o que pode ser paralelo e manter sob controle o que pode entrar em conflito.
Não adianta colocar cinco agentes trabalhando freneticamente se três deles estão tentando consertar a mesma coisa.
E se você quiser criar um checkout? 🛒
O exemplo de comércio eletrônico do material é ótimo para mostrar como especificar uma tarefa mais complexa.
Prompt 7: checkout com ambiente seguro
Crie um protótipo de checkout para uma loja virtual.
Funcionalidades:
- carrinho de compras;
- autenticação;
- resumo do pedido;
- formulário de checkout;
- integração com Stripe em modo de teste;
- página de confirmação.
Fluxo esperado:
1. Usuário adiciona um produto ao carrinho.
2. Abre o checkout.
3. Confere o pedido.
4. Inicia o pagamento.
5. Conclui um pagamento de teste.
6. Visualiza a confirmação.
Regras:
- Não use chaves reais.
- Não faça transações reais.
- Não faça deploy.
- Não altere arquivos fora do projeto sem aprovação.
- Antes de implementar, apresente o plano.
- Depois da implementação, teste o fluxo completo no navegador.
- Gere screenshots dos principais passos.
- Informe qualquer etapa que não tenha sido possível verificar.
Aqui aparece uma regra que vale para praticamente qualquer agente conectado a serviços externos:
use ambientes de teste enquanto você ainda está aprendendo o comportamento da ferramenta.
Um cartão de teste é muito mais barato do que descobrir um erro com uma cobrança real.
Prompt para pedir uma auditoria antes de aceitar o resultado 🔍
Nem sempre você precisa mandar o agente corrigir tudo.
Às vezes, é melhor pedir uma segunda leitura.
Prompt 8: seja o revisor
Atue como revisor deste projeto.
Não altere nenhum arquivo.
Analise:
- erros funcionais;
- problemas de arquitetura;
- possíveis falhas de segurança;
- dependências desnecessárias;
- tratamento de erros;
- problemas de experiência do usuário;
- testes ausentes;
- riscos para produção.
Para cada problema encontrado, informe:
1. gravidade;
2. arquivo ou componente afetado;
3. motivo;
4. sugestão de correção;
5. como verificar a correção.
Priorize os problemas por impacto, mas não faça alterações.
Esse prompt cria uma separação útil entre quem executa e quem revisa.
Mesmo que os dois papéis sejam desempenhados pelo mesmo modelo, a mudança de instrução pode ajudar a produzir uma segunda análise em vez de simplesmente assumir que tudo feito anteriormente estava correto.
E quando aparecer uma tarefa perigosa? ⚠️
É aqui que você deve ser explícito.
Se a operação puder apagar arquivos, alterar infraestrutura, publicar código ou mexer em dados, diga ao agente o que ele não está autorizado a fazer.
Prompt 9: operações sensíveis exigem aprovação
Você tem autorização para analisar e modificar apenas os arquivos deste projeto.
NÃO está autorizado a:
- apagar diretórios fora do projeto;
- executar comandos destrutivos;
- alterar configurações do sistema operacional;
- acessar credenciais;
- fazer push para repositórios remotos;
- fazer deploy;
- modificar bancos de dados de produção;
- enviar dados para serviços externos não autorizados.
Se qualquer uma dessas ações parecer necessária:
1. pare;
2. explique por que ela é necessária;
3. mostre o comando ou alteração proposta;
4. aguarde minha aprovação explícita.
Para comandos potencialmente destrutivos, sempre peça confirmação.
Não é uma garantia absoluta de segurança.
Mas transforma a intenção em uma regra operacional clara.
E, em um sistema com capacidade de agir, isso importa.
Um prompt para entender o que a IA realmente fez 🧾
Depois de uma tarefa longa, não aceite apenas “concluído”.
Peça uma prestação de contas.
Prompt 10: gere o recibo da missão
Crie um relatório final da tarefa.
Inclua:
- objetivo original;
- plano executado;
- arquivos modificados;
- arquivos criados;
- comandos relevantes executados;
- testes realizados;
- resultados dos testes;
- verificações no navegador;
- screenshots ou outras evidências disponíveis;
- problemas encontrados;
- correções realizadas;
- limitações da validação;
- ações que NÃO foram executadas.
Não diga apenas que a tarefa foi concluída.
Mostre as evidências que sustentam essa conclusão.
Esse é provavelmente um dos prompts mais úteis de toda a experiência.
Porque ele muda a conversa de “confie em mim” para “aqui está o que eu fiz e como você pode conferir”.
O prompt mestre para começar um projeto 🚀
Depois de experimentar os passos anteriores, você pode juntar tudo em uma única instrução mais completa.
Quero construir:
[DESCREVA O PRODUTO OU FUNCIONALIDADE]
Seu objetivo é levar a tarefa do planejamento até uma implementação funcional e verificável.
FASE 1 — PLANEJAMENTO
- Analise o projeto existente.
- Identifique arquivos, dependências e riscos.
- Divida o trabalho em etapas.
- Identifique quais tarefas podem ser executadas em paralelo.
- Crie um plano detalhado.
- Não faça alterações ainda.
FASE 2 — APROVAÇÃO
- Mostre o plano.
- Destaque decisões que exigem minha autorização.
- Aguarde minha aprovação.
FASE 3 — IMPLEMENTAÇÃO
- Execute apenas o que foi aprovado.
- Faça alterações pequenas e verificáveis.
- Não instale dependências inesperadas sem me avisar.
- Não use credenciais reais.
- Não faça deploy ou push sem autorização.
FASE 4 — TESTES
- Execute os testes relevantes.
- Inicie a aplicação quando necessário.
- Use o navegador para validar a experiência.
- Teste os fluxos principais.
- Capture screenshots e outras evidências.
FASE 5 — CORREÇÃO
- Se encontrar problemas, identifique a causa.
- Corrija apenas o necessário.
- Repita os testes após cada correção relevante.
FASE 6 — ENTREGA
Produza um Artifact final contendo:
- resumo do que foi feito;
- arquivos alterados;
- testes executados;
- resultados;
- evidências;
- problemas conhecidos;
- limitações;
- próximos passos.
REGRA DE SEGURANÇA:
Se uma ação puder causar perda de dados, acessar informações sensíveis, modificar o sistema, publicar código ou afetar produção, pare e peça minha aprovação explícita.
O segredo não está em escrever prompts gigantes 🧠
É tentador concluir que quanto maior o prompt, melhor será o agente.
Não necessariamente.
O que faz diferença é definir objetivo, limites, critérios de sucesso e pontos de aprovação.
Um bom prompt para agente normalmente responde a cinco perguntas:
| Pergunta | O que especificar |
|---|---|
| O quê? | Qual resultado você quer |
| Como? | Quais etapas ou critérios devem ser seguidos |
| Até onde? | Quais ações estão proibidas ou exigem aprovação |
| Como testar? | O que precisa funcionar para considerar a tarefa concluída |
| Como provar? | Quais Artifacts ou evidências devem ser entregues |
Isso também explica por que simplesmente escrever “construa um aplicativo” pode funcionar em uma demonstração, mas ser uma instrução ruim para um ambiente real.
O agente precisa saber onde termina a missão.
Um último teste: peça para o agente discordar de você 🔎
Existe ainda um truque interessante para tarefas complexas.
Em vez de perguntar apenas “como faço isso?”, pergunte quais são os riscos da sua própria ideia.
Prompt 11: procure problemas antes de construir
Antes de implementar esta solução, tente encontrar motivos para NÃO construí-la desta forma.
Analise:
- requisitos ambíguos;
- riscos técnicos;
- riscos de segurança;
- custos de infraestrutura;
- dependências externas;
- possíveis pontos de falha;
- casos extremos;
- problemas que poderiam aparecer em produção.
Não proponha uma solução alternativa automaticamente.
Primeiro liste os problemas e explique quais precisam ser resolvidos antes da implementação.
Esse tipo de instrução é particularmente útil porque impede que o agente trate a primeira ideia apresentada como verdade absoluta.
A IA deixa de ser apenas uma máquina de execução e passa a funcionar, naquele momento, como uma espécie de revisor técnico.
Do primeiro prompt ao agente autônomo
O caminho mais seguro para aprender Antigravity não é começar no modo mais autônomo.
É aumentar a autonomia conforme você aprende a verificar o resultado.
Comece pequeno.
Depois, experimente uma tarefa com terminal.
Em seguida, adicione testes no navegador.
Depois, tente dividir uma missão entre agentes.
Só então faz sentido aumentar as permissões ou conectar serviços externos.
A lógica é quase a mesma de ensinar alguém a dirigir: primeiro você aprende a controlar o carro em um lugar tranquilo. Só depois coloca trânsito, estrada e passageiros na equação.
No Antigravity, esses “passageiros” podem ser seu código, seus dados, suas credenciais e, eventualmente, seus clientes.
E é justamente por isso que o melhor prompt não é necessariamente aquele que diz à IA para fazer mais.
É aquele que deixa cristalino o que ela pode fazer, o que não pode fazer e como você vai conferir o resultado antes de deixá-la seguir viagem.
