Introdução ao Google Antigravity

1. Introdução

Neste codelab, você vai conhecer o Google Antigravity (chamado de Antigravity no restante do documento), uma plataforma de desenvolvimento de agentes que evolui o ambiente de desenvolvimento integrado para a era focada em agentes.

Ao contrário dos assistentes de programação padrão que apenas preenchem linhas automaticamente, o Antigravity oferece uma "Central de controle" para gerenciar agentes autônomos que podem planejar, programar e até navegar na Web para ajudar você a criar.

O Antigravity foi projetado como uma plataforma focada em agentes. Isso pressupõe que a IA não é apenas uma ferramenta para escrever código, mas um agente autônomo capaz de planejar, executar, validar e iterar tarefas complexas de engenharia com intervenção humana mínima.

O que você vai aprender

• Instalação e configuração do Antigravity.
• Conheça os principais conceitos do Antigravity, como gerenciador de agentes, editor, navegador e muito mais.
• Analisando alguns casos de uso com o Antigravity.

O que é necessário

No momento, o Antigravity está disponível como prévia para contas pessoais do Gmail. Ele vem com uma cota sem custo financeiro para usar modelos avançados.

O Antigravity precisa ser instalado localmente no seu sistema. O produto está disponível para Mac, Windows e distribuições específicas do Linux. Além da sua máquina, você vai precisar do seguinte:

• Navegador da Web Google Chrome
• Uma conta do Gmail (conta pessoal do Gmail).

Este codelab foi criado para usuários e desenvolvedores de todos os níveis, inclusive iniciantes.

Problemas de relatório

Ao trabalhar no codelab e com o Antigravity, você pode encontrar problemas.

Para problemas relacionados ao codelab (erros de digitação, instruções incorretas), abra um bug com o botão Report a mistake no canto inferior esquerdo deste codelab:

Para bugs ou solicitações de recursos relacionados ao Antigravity, informe o problema no próprio app. Isso pode ser feito no Gerenciador de agentes com o link Provide Feedback no canto inferior esquerdo:

Você também pode acessar o editor com o link Report Issue abaixo do ícone do seu perfil:

2. Instalação

Vamos começar instalando o Antigravity. No momento, o produto está disponível para prévia, e você pode usar sua conta pessoal do Gmail para começar a usar.

Acesse a página de downloads e clique na versão do sistema operacional adequada ao seu caso. Inicie o instalador de aplicativos e instale-o na sua máquina. Depois de concluir a instalação, inicie o aplicativo Antigravity. Uma tela semelhante a esta vai aparecer:

Clique em Next a cada vez. Confira abaixo as principais etapas:

• Escolha o fluxo de configuração:isso abre a opção de importar das configurações atuais do VS Code ou do Cursor. Vamos começar do zero.
• Escolha um tipo de tema do editor: vamos usar o tema escuro, mas a escolha é sua.
• Como você quer usar o agente antigravidade?

Vamos entender isso com mais detalhes. As configurações podem ser alteradas a qualquer momento nas configurações do usuário do Antigravity (Cmd + ,).

Antes de analisarmos as opções, vamos conferir algumas propriedades específicas (que aparecem à direita da caixa de diálogo).

Política de execução de terminal

Isso permite que o agente execute comandos (aplicativos/ferramentas) no seu terminal:

• Sempre continuar:sempre execute automaticamente os comandos do terminal, exceto aqueles em uma lista de bloqueio configurável.
• Solicitar revisão:peça a revisão e aprovação do usuário antes de executar comandos do terminal.

Política de avaliações

À medida que o agente realiza a tarefa, ele cria vários artefatos (plano de tarefas, plano de implementação etc.). A política de revisão é definida para que você possa determinar quem decide se ela precisa ser revisada. Você quer sempre revisar ou deixar que o representante decida? Portanto, há três opções aqui também.

• Sempre continuar:o agente nunca pede uma revisão.
• O agente decide:o agente decide quando pedir uma revisão.
• Pedir revisão:o agente sempre pede uma revisão.

Política de execução de JavaScript

Quando ativado, o agente pode usar ferramentas do navegador para abrir URLs, ler páginas da Web e interagir com o conteúdo do navegador. Essa política controla como o JavaScript é executado no navegador.

• Sempre continuar:o agente não vai parar para pedir permissão para executar JavaScript no navegador. Isso oferece ao agente autonomia máxima para realizar ações complexas e validação no navegador, mas também tem a maior exposição a exploits de segurança.
• Solicitar revisão:o agente sempre para para pedir permissão para executar código JavaScript no navegador.
• Desativado:o agente nunca vai executar código JavaScript no navegador.

Agora que entendemos as diferentes políticas, as quatro opções à esquerda são apenas configurações específicas para a execução do terminal, revisão e políticas de execução do JavaScript para três delas e uma quarta opção disponível em que podemos controlar completamente a personalização. Essas quatro opções estão disponíveis para que possamos escolher quanta autonomia você quer dar ao agente para executar comandos no terminal e revisar artefatos antes de continuar com a tarefa.

As quatro opções são:

• Modo seguro: o modo seguro oferece controles de segurança aprimorados para o agente, permitindo restringir o acesso dele a recursos externos e operações sensíveis. Quando o modo seguro está ativado, várias medidas de segurança são aplicadas para proteger seu ambiente.
• Desenvolvimento orientado por revisão (recomendado): o agente vai pedir revisões com frequência.
• Desenvolvimento orientado por agente: o agente nunca pede revisão.
• Configuração personalizada

A opção Desenvolvimento orientado por revisão é um bom equilíbrio e a recomendada, já que permite que o agente tome uma decisão e volte ao usuário para aprovação.

Em seguida, na página Configurar seu editor, escolha suas preferências para o seguinte:

• Vinculações de teclas: configure suas vinculações de teclas.
• Extensões: instale extensões de linguagem conhecidas e outras recomendadas.
• Linha de comando: instale a ferramenta de linha de comando para abrir o Antigravidade com agy.

Agora você já pode fazer login no Google. Como mencionado anteriormente, o Antigravity está disponível no modo de prévia e é sem custo financeiro para quem tem uma conta pessoal do Gmail. Faça login agora com sua conta. Isso vai abrir o navegador para você fazer login. Após a autenticação, você vai ver uma mensagem semelhante à abaixo, que vai levar você de volta ao aplicativo Antigravity. Me deixo levar

Por fim, os Termos de Uso. Decida se quer ativar ou não e clique em Next.

Isso vai levar você ao momento da verdade, em que a Antigravity estará esperando para colaborar com você.

3. Gerente de representante

Tudo pronto para começar!

O Antigravity deriva da base de código aberto do Visual Studio Code (VS Code), mas altera radicalmente a experiência do usuário para priorizar o gerenciamento de agentes em vez da edição de texto. A interface é dividida em duas janelas principais distintas: Editor e Agent Manager. Essa separação de responsabilidades reflete a distinção entre contribuição individual e gerenciamento de engenharia.

Gerente de agentes: controle de missão

Ao iniciar o Antigravity, o usuário geralmente não encontra uma árvore de arquivos, mas sim o Gerenciador de agentes, conforme mostrado abaixo:

Essa interface funciona como um painel Mission Control. Ele foi projetado para orquestração de alto nível, permitindo que os desenvolvedores criem, monitorem e interajam com vários agentes operando de forma assíncrona em diferentes espaços de trabalho ou tarefas.

Nessa visão, o desenvolvedor atua como um arquiteto. Eles definem objetivos de alto nível, como:

• Refatorar o módulo de autenticação
• Atualizar a árvore de dependências
• Gerar um conjunto de testes para a API Billing

Como o diagrama acima indica, cada uma dessas solicitações gera uma instância de agente dedicada. A interface mostra uma visualização desses fluxos de trabalho paralelos, exibindo o status de cada agente, os artefatos que eles produziram (planos, resultados, diferenças) e solicitações pendentes de aprovação humana.

Essa arquitetura aborda uma limitação importante dos IDEs anteriores, que tinham mais uma experiência de chatbot linear e síncrona. Em uma interface de chat tradicional, o desenvolvedor precisa esperar que a IA termine de gerar o código antes de fazer a próxima pergunta. Na visualização do gerente do Antigravity, um desenvolvedor pode enviar cinco agentes diferentes para trabalhar em cinco bugs diferentes simultaneamente, multiplicando efetivamente a capacidade de processamento.

Se você clicar em Next acima, poderá abrir um espaço de trabalho.

Pense no espaço de trabalho como você o conhecia no VS Code. Para abrir uma pasta local, clique no botão e selecione uma pasta para começar. No meu caso, eu tinha uma pasta na minha pasta inicial chamada my-agy-projects, e foi ela que eu selecionei. Você pode usar uma pasta completamente diferente. Você pode pular essa etapa completamente se quiser e abrir um espaço de trabalho a qualquer momento depois.

Depois de concluir essa etapa, você vai estar na janela do Agent Manager, mostrada abaixo:

O aplicativo vai iniciar imediatamente uma nova conversa na pasta do espaço de trabalho (my-agy-projects) selecionada. Você pode usar seu conhecimento sobre outros aplicativos de IA (Cursor, CLI do Gemini) e usar @ e outras maneiras de incluir mais contexto ao fazer solicitações.

Confira os menus suspensos Planning e Model Selection. No menu suspenso "Seleção de modelo", você pode escolher um dos modelos disponíveis no momento para o agente usar. Confira a lista abaixo:

Da mesma forma, o agente vai estar em um modo Planning padrão. Mas também podemos usar o modo Fast.

Vamos ver o que a documentação diz sobre isso:

• Planning: um agente pode planejar antes de executar tarefas. Use para pesquisas detalhadas, tarefas complexas ou trabalho colaborativo. Nesse modo, o agente organiza o trabalho em grupos de tarefas, produz artefatos e realiza outras etapas para pesquisar, pensar e planejar o trabalho de forma completa para uma qualidade ideal. Você vai ver muito mais resultados aqui.
• Fast: um agente executa tarefas diretamente. Use para tarefas simples que podem ser concluídas mais rapidamente, como renomear variáveis, iniciar alguns comandos bash ou outras tarefas menores e localizadas. Isso é útil quando a velocidade é um fator importante e a tarefa é simples o suficiente para não se preocupar com a qualidade.

Se você conhece o orçamento de pensamento e termos semelhantes em agentes, pense nisso como a capacidade de controlar o pensamento do agente, tendo assim um impacto direto no orçamento de pensamento. Por enquanto, vamos usar os padrões. No entanto, lembre-se de que, no momento do lançamento, a disponibilidade do modelo Gemini 3 Pro será limitada a todos. Portanto, espere mensagens indicando se você esgotou essas cotas sem custo financeiro para o uso do Gemini 3.

Vamos passar um tempo agora no Gerenciador de agentes (janela) e entender algumas coisas para que fique claro sobre os blocos de construção básicos, como navegar no Antigravity e muito mais. A janela do Gerenciador de agentes é mostrada abaixo:

Consulte o diagrama acima com os números:

1. Inbox: pense nisso como uma forma de acompanhar todas as suas conversas em um só lugar. À medida que você envia os agentes para as tarefas, elas aparecem na caixa de entrada. Clique nela para ver uma lista de todas as conversas atuais. Ao tocar em qualquer uma das conversas, você terá acesso a todas as mensagens trocadas, ao status das tarefas, ao que o agente produziu ou até mesmo se ele está aguardando uma aprovação sua nas tarefas. Essa é uma ótima maneira de voltar depois a uma tarefa anterior em que você estava trabalhando. Um recurso muito útil.
2. Start Conversation: clique aqui para iniciar uma nova conversa. Isso vai levar você diretamente à entrada onde está escrito Ask anything.
3. Workspaces: mencionamos os espaços de trabalho e que você pode trabalhar em qualquer um deles. Você pode adicionar mais espaços de trabalho a qualquer momento e selecionar qualquer um deles ao iniciar a conversa.
4. Playground: uma ótima maneira de iniciar uma conversa com o agente e, se quiser, converter em um espaço de trabalho, onde você tem um controle mais rígido sobre os arquivos etc. Pense nisso como uma área de rascunho.
5. Editor View: até agora, estamos na visualização do Gerenciador de agentes. Você pode mudar para a visualização do editor a qualquer momento. Isso vai mostrar a pasta do espaço de trabalho e todos os arquivos gerados. Você pode editar os arquivos diretamente ou fornecer orientação inline, comando no editor, para que o agente possa fazer algo ou mudar de acordo com suas recomendações/instruções modificadas. Vamos abordar a visualização do editor em detalhes em uma seção posterior.
6. Browser: por fim, chegamos a um dos diferenciais claros que torna o Antigravity muito eficiente: a integração estreita com o navegador Chrome. Vamos começar a configurar o navegador na próxima seção.

4. Navegador Antigravity

Conforme a documentação, quando o agente quer interagir com o navegador, ele invoca um subagente do navegador para lidar com a tarefa em questão. O subagente do navegador executa um modelo especializado para operar nas páginas abertas no navegador gerenciado pelo Antigravity, que é diferente do modelo selecionado para o agente principal.

Esse subagente tem acesso a várias ferramentas necessárias para controlar seu navegador, incluindo clicar, rolar, digitar, ler registros do console e muito mais. Ele também pode ler suas páginas abertas por captura de DOM, capturas de tela ou análise de markdown, além de gravar vídeos.

Isso significa que precisamos iniciar e instalar a extensão do navegador Antigravity. Para isso, vamos iniciar uma conversa no Playground e seguir as etapas.

Selecione Playground e dê ao agente a seguinte tarefa go to antigravity.google, conforme mostrado abaixo:

Envie a tarefa. Você vai ver o agente analisando a tarefa e poderá inspecionar o processo de raciocínio. Em algum momento, ele vai continuar corretamente e mencionar que precisa configurar o agente do navegador, conforme mostrado abaixo. Clique em Setup.

Isso vai abrir o navegador e mostrar uma mensagem para instalar a extensão, como mostrado abaixo:

Em seguida, você será direcionado para a extensão do Chrome, que poderá ser instalada.

Depois de instalar a extensão, o agente antigravidade vai começar a trabalhar e indicar que você precisa permitir que ele faça a tarefa. Você vai notar alguma atividade na janela do navegador que foi aberta:

Volte para a visualização do Gerenciador de agentes. Você vai ver o seguinte:

Isso é exatamente o que esperávamos que acontecesse, já que pedimos ao agente para acessar o site antigravity.google. Conceda a permissão e você vai descobrir que o site foi acessado com segurança, conforme mostrado abaixo:

5. Artefatos

O Antigravity cria artefatos enquanto planeja e realiza o trabalho para se comunicar e receber feedback do usuário humano. São arquivos Markdown avançados, diagramas de arquitetura, imagens, gravações do navegador, diferenças de código etc.

Os artefatos resolvem a lacuna de confiança. Quando um agente afirma: "Corrigi o bug", o desenvolvedor precisava ler o código para verificar. Em Antigravity, o agente produz um artefato para provar isso.

Estes são os principais artefatos produzidos pelo Antigravity:

• Task Lists: antes de escrever o código, o agente gera um plano estruturado. Normalmente, não é necessário editar esse plano, mas você pode revisá-lo e, em alguns casos, adicionar um comentário para mudar, se necessário.
• Implementation Plan: usado para arquitetar mudanças na sua base de código e realizar uma tarefa. Esses planos contêm detalhes técnicos sobre quais revisões são necessárias e devem ser analisados pelo usuário, a menos que sua política de revisão de artefatos esteja definida como "Sempre continuar".
• Walkthrough: criado depois que o agente conclui a implementação da tarefa, como um resumo das mudanças e de como testá-las.
• Code diffs: embora tecnicamente não seja um artefato, o Antigravity também produz diferenças de código que podem ser revisadas e comentadas.
• Screenshots: o agente captura o estado da interface antes e depois de uma mudança.
• Browser Recordings: para interações dinâmicas (por exemplo, "Clique no botão de login, aguarde o spinner e verifique se o painel carrega"), o agente grava um vídeo da sessão. O desenvolvedor pode assistir a este vídeo para verificar se o requisito funcional foi atendido sem executar o app.

Os artefatos são produzidos e aparecem nas visualizações do Gerenciador de agentes e do Editor.

Na visualização do editor, no canto inferior direito, clique em Artifacts:

Na visualização do Gerenciador de agentes, no canto superior direito, ao lado de Review changes, você encontra um botão para ativar/desativar os artefatos. Se ele estiver ativado, a lista de artefatos gerados vai aparecer:

A visualização "Artefatos" vai aparecer como mostrado abaixo. No nosso caso, instruímos o agente a acessar a página antigravity.google. Por isso, ele capturou a captura de tela e criou um vídeo dela:

É possível ver as diferenças de código em Review Changes na visualização do editor:

Os desenvolvedores podem interagir com esses artefatos e diffs de código usando "comentários no estilo do Google Docs". Você pode selecionar uma ação ou tarefa específica, dar um comando da maneira que quiser e enviar para o agente. O agente vai processar esse feedback e fazer as mudanças necessárias. Pense em usar o Google Docs interativo, em que você dá feedback ao autor, e ele faz uma nova versão com base nisso.

6. Revisitar a Caixa de entrada

Se você já iniciou algumas conversas com os agentes, confira seu Inbox na janela Agent Manager. Todas as conversas vão aparecer. Clique em qualquer uma das conversas para conferir o histórico, os artefatos produzidos e muito mais. No nosso caso, depois de executar a primeira conversa, a caixa de entrada mostra a conversa listada, conforme mostrado abaixo:

Ao clicar nessa conversa, você terá acesso aos detalhes:

Você também pode continuar a conversa aqui.

7. Editor

O editor mantém a familiaridade do VS Code, garantindo que a memória muscular dos desenvolvedores experientes seja respeitada. Ele inclui o explorador de arquivos padrão, o destaque de sintaxe e o ecossistema de extensões.

Clique no botão Open Editor no canto superior direito do Gerenciador de agentes para acessar o Editor.

Configuração e extensões

Em uma configuração típica, o editor, o terminal e o agente ficam visíveis:

Se esse não for o caso, alterne os painéis do terminal e do agente da seguinte maneira:

• Para ativar ou desativar o painel do terminal, use o atalho Ctrl + `.
• Para ativar ou desativar o painel do agente, use o atalho Cmd + L.

Além disso, o Antigravity pode instalar algumas extensões durante a configuração, mas, dependendo da linguagem de programação que você está usando, provavelmente será necessário instalar mais extensões. Por exemplo, para desenvolvimento em Python, estas são as extensões que você pode instalar:

Editor

Preenchimento automático

Ao digitar o código no editor, um preenchimento automático inteligente é ativado. Basta pressionar a tecla Tab:

Use a tecla Tab para importar

Você recebe a sugestão toque para importar para adicionar dependências ausentes:

Use a tecla Tab para pular

Você recebe sugestões de tab para pular e mover o cursor para o próximo local lógico no código:

Comandos

É possível acionar comandos com Cmd + I no editor ou terminal para conclusões inline usando linguagem natural.

No editor, você pode pedir um método para calcular números de Fibonacci e aceitar ou rejeitar a sugestão:

No terminal, você pode receber sugestões de comandos:

Painel lateral do agente

No editor, você pode ativar e desativar o painel lateral do agente de várias maneiras.

Abertura manual

É possível ativar ou desativar manualmente o painel do agente à direita com o atalho Cmd + L.

Você pode começar a fazer perguntas, usar @ para incluir mais contexto, como arquivos, diretórios, servidores MCP, ou usar / para se referir a um fluxo de trabalho (um comando salvo):

Você também pode escolher entre dois modos de conversa: Fast ou Planning :

O Fast é recomendado para tarefas rápidas, enquanto o Planning é recomendado para tarefas mais complexas em que o agente cria um plano que você pode aprovar.

Você também pode escolher modelos diferentes para a conversa:

Explicar e corrigir

Outra maneira de acionar o agente é passar o cursor sobre um problema e selecionar Explain and fix:

Enviar problemas ao agente

Você também pode acessar a seção Problems e selecionar Send all to Agent para que o agente tente corrigir esses problemas:

Enviar saída do terminal para o agente

Você pode até selecionar uma parte da saída do terminal e enviar para o agente com Cmd + L:

Alternar entre Editor e Gerente de agente

A qualquer momento, você pode alternar entre o modo de editor e o modo completo do gerenciador de agentes clicando no botão Open Agent Manager no canto superior direito quando estiver no modo de editor e vice-versa clicando no botão Open Editor no canto superior direito quando estiver no modo do gerenciador de agentes.

Como alternativa, use o atalho de teclado Cmd + E para alternar entre os dois modos.

8. Enviar feedback

A principal característica do Antigravity é a capacidade de coletar seu feedback sem esforço em todas as etapas da experiência. À medida que o agente trabalha em uma tarefa, ele cria diferentes artefatos ao longo do caminho:

• Um plano de implementação e uma lista de tarefas (antes da programação)
• Diferenças de código (enquanto gera código)
• Um tutorial para verificar os resultados (após a codificação)

Esses artefatos são uma maneira de a Antigravity comunicar seus planos e progresso. Eles também são uma forma de dar feedback ao agente no estilo de comentários do Google Docs. Isso é muito útil para direcionar o agente de maneira eficaz.

Vamos tentar criar um aplicativo de lista de tarefas simples e ver como podemos dar feedback para o Antigravity ao longo do processo.

Modo de planejamento

Primeiro, verifique se o Antigravity está no modo Planning em vez de Fast. Você pode selecionar essa opção no chat do painel lateral do agente. Isso garante que o Antigravity crie um plano de implementação e uma lista de tarefas antes de começar a programar. Depois, tente um comando, algo como: Create a todo list web app using Python. Isso vai iniciar o agente para começar a planejar e produzir um plano de implementação.

Plano de implementação

Um plano de implementação é uma visão geral do que a Antigravity pretende fazer, qual stack de tecnologia será usada e uma descrição de alto nível das mudanças propostas.

Implementation Plan - Python Todo App
Goal
Create a simple, functional, and aesthetically pleasing Todo List web application using Python (Flask).

Tech Stack
Backend: Python with Flask
Frontend: HTML5, CSS3 (Vanilla), Jinja2 templates
...

É também o primeiro lugar em que você pode enviar feedback. Neste caso, o agente quer usar o Flask como framework da Web em Python. Podemos adicionar um comentário ao plano de implementação para usar o FastAPI. Depois de adicionar o comentário, envie-o ou peça à Antigravity para Proceed com o plano de implementação atualizado.

Lista de tarefas

Depois que o plano de implementação é atualizado, o Antigravity cria uma lista de tarefas. Esta é uma lista concreta de etapas que o Antigravity vai seguir para criar e verificar o app.

Task Plan
 Create requirements.txt
 Create directory structure (static/css, templates)
 Create static/css/style.css
 Create templates/index.html
 Create main.py with FastAPI setup and Database logic
 Verify application

Este é o segundo lugar em que você pode enviar feedback.

Por exemplo, no nosso caso de uso, você pode adicionar instruções de verificação mais detalhadas incluindo o seguinte comentário: Verify application by adding, editing, and deleting a todo item and taking a screenshot.

Algumas dicas ao trabalhar com feedbacks:

1. Sempre que você adicionar um comentário aos planos ou tarefas, não se esqueça de enviar. Isso aciona a atualização dos planos da Antigravity.
2. Às vezes, o Antigravity vai direto para a programação depois de criar um plano de implementação e uma lista de tarefas sem esperar sua confirmação. Nesses casos, você ainda pode comentar sobre os planos/tarefas e enviar novamente. Isso vai atualizar o código e o tutorial depois. Você também pode interromper a tarefa de programação, adicionar comentários a planos/tarefas e tentar de novo.

Mudanças no código

Neste ponto, o Antigravity vai gerar um código em novos arquivos. Você pode Accept all ou Reject all essas mudanças no painel lateral de chat do representante sem analisar os detalhes.

Você também pode clicar em Review changes para conferir os detalhes das mudanças e adicionar comentários detalhados ao código. Por exemplo, podemos adicionar o seguinte comentário em main.py: Add basic comments to all methods

Essa é uma ótima maneira de iterar no código com o Antigravity.

Tutorial

Depois que o Antigravity termina de programar, ele inicia o servidor e abre um navegador para verificar o app. Ele faz alguns testes manuais, como adicionar e atualizar tarefas etc. Tudo isso graças à extensão do navegador Antigravity. No final, ele cria um arquivo de tutorial para resumir o que foi feito para verificar o app. Isso inclui uma captura de tela ou um fluxo de verificação com uma gravação do navegador.

Você também pode comentar sobre a captura de tela ou a gravação do navegador no tutorial. Por exemplo, podemos adicionar um comentário Change the blue theme to orange theme e enviar. Depois que o comentário é enviado, o Antigravity faz as mudanças, verifica os resultados e atualiza o tutorial.

Desfazer alterações

Por fim, depois de cada etapa, se você não gostar da mudança, é possível desfazer a ação no chat. Basta escolher o ↩️ Undo changes up to this point no chat.

9. Regras e fluxos de trabalho

O Antigravity vem com algumas opções de personalização: Regras e Fluxos de trabalho.

Clique em ... no canto superior direito e escolha Customizations. Você vai ver Rules e Workflows:

As regras ajudam a orientar o comportamento do agente. São diretrizes que você pode fornecer para garantir que o agente siga ao gerar código e testes. Por exemplo, talvez você queira que o agente siga um determinado estilo de código ou sempre documente os métodos. Você pode adicionar essas informações como regras, e o agente vai considerá-las.

Os fluxos de trabalho são comandos salvos que podem ser acionados sob demanda com / enquanto você interage com o agente. Elas também orientam o comportamento do agente, mas são acionadas pelo usuário sob demanda.

Uma boa analogia é que as regras são mais parecidas com instruções do sistema, enquanto os fluxos de trabalho são mais parecidos com comandos salvos que você pode escolher sob demanda.

As Regras e os Fluxos de trabalho podem ser aplicados globalmente ou por espaço de trabalho e salvos nos seguintes locais:

• Regra global: ~/.gemini/GEMINI.md
• Fluxo de trabalho global: ~/.gemini/antigravity/global_workflows/global-workflow.md
• Regras do Workspace: your-workspace/.agent/rules/
• Fluxos de trabalho do Workspace: your-workspace/.agent/workflows/

Vamos adicionar algumas regras e fluxos de trabalho no espaço de trabalho.

Adicionar uma regra

Primeiro, vamos adicionar uma regra de estilo de código. Acesse Rules e selecione o botão +Workspace. Dê um nome a ele, como code-style-guide, com as seguintes regras de estilo de código:

* Make sure all the code is styled with PEP 8 style guide
* Make sure all the code is properly commented

Em seguida, vamos adicionar outra regra para garantir que o código seja gerado de forma modular com exemplos em uma regra code-generation-guide:

* The main method in main.py is the entry point to showcase functionality.
* Do not generate code in the main method. Instead generate distinct functionality in a new file (eg. feature_x.py)
* Then, generate example code to show the new functionality in a new method in main.py (eg. example_feature_x) and simply call that method from the main method.

As duas regras são salvas e ficam prontas:

Adicionar um fluxo de trabalho

Vamos também definir um fluxo de trabalho para gerar testes de unidade. Isso vai permitir que acionemos testes de unidade quando estivermos satisfeitos com o código, em vez de o agente gerar testes de unidade o tempo todo.

Acesse Workflows e selecione o botão +Workspace. Dê um nome a ele, como generate-unit-tests, com o seguinte:

* Generate unit tests for each file and each method
* Make sure the unit tests are named similar to files but with test_ prefix

O fluxo de trabalho também está pronto para ser usado:

Faça um teste

Agora vamos ver as regras e os fluxos de trabalho em ação. Crie um arquivo main.py de esqueleto no seu espaço de trabalho:

def main():
    pass

if __name__ == "__main__":
    main()

Agora, acesse a janela de conversa com o agente e pergunte: Implement binary search and bubble sort.

Depois de um ou dois minutos, você vai receber três arquivos no espaço de trabalho: main.py, bubble_sort.py e binary_search.py. Você também vai notar que todas as regras estão implementadas: o arquivo principal não está desordenado e tem o código de exemplo, cada recurso é implementado no próprio arquivo, todo o código está documentado e em bom estilo:

from binary_search import binary_search, binary_search_recursive
from bubble_sort import bubble_sort, bubble_sort_descending


def example_binary_search():
    """
    Demonstrate binary search algorithm with various test cases.
    """
    ...

def example_bubble_sort():
    """
    Demonstrate bubble sort algorithm with various test cases.
    """
    ...

def main():
    """
    Main entry point to showcase functionality.
    """
    example_binary_search()
    example_bubble_sort()
    print("\n" + "=" * 60)


if __name__ == "__main__":
    main()

Agora que estamos satisfeitos com o código, vamos ver se podemos acionar o fluxo de trabalho de geração de teste de unidade.

Acesse o chat e comece a digitar /generate. A Antigravity já conhece nosso fluxo de trabalho:

Selecione generate-unit-tests e pressione Enter. Depois de alguns segundos, você vai receber novos arquivos no espaço de trabalho: test_binary_search.py, test_bubble_sort.py com vários testes já implementados.

Legal!

10. Como proteger o agente

Dar acesso a um agente de IA ao seu terminal e navegador é uma faca de dois gumes. Ele permite a depuração e a implantação autônomas, mas também abre vetores para injeção de comandos e exfiltração de dados.

O Antigravity resolve isso com um sistema granular de permissões que gira em torno de políticas de execução automática de comandos do terminal e listas de permissões e negações.

Ao configurar o Antigravity pela primeira vez ou no menu de configurações, você precisa selecionar uma política de Terminal Command Auto Execution. Essa configuração determina a autonomia do agente em relação aos comandos do shell.

Para conferir suas configurações atuais, acesse Antigravity — Settings e Advanced Settings. Você vai encontrar a seção Terminal nas configurações do agente. Tenha em mente esta tabela se quiser mudar essa configuração para outra coisa:

Modo de política	Descrição
Desativado	O agente nunca executa comandos de terminal automaticamente, a menos que isso seja permitido explicitamente.
Automático	O agente decide se vai executar com base em modelos de segurança internos. Ele pede permissão para comandos arriscados.
Turbo	O agente sempre executa comandos automaticamente, a menos que seja explicitamente negado.

Configurar a lista de permissões

A lista de permissões é usada principalmente com a política Desativada. Ele representa um modelo de segurança positivo, ou seja, tudo é proibido, a menos que seja expressamente permitido. Essa é a configuração mais segura.

Configuração detalhada

1. Defina a opção Execução automática de comandos do terminal como Desativada.
2. Adicione o seguinte comando em Permitir comandos do terminal clicando no botão Adicionar ao lado dele : ls -al . Você também pode adicionar outros comandos de terminal, se quiser.

Testar a lista de permissões

• Pergunte ao agente: List the files in this directory.
• O agente executa ls automaticamente.
• Pergunte ao agente: Delete the <some file>
• O agente vai tentar rm <filepath>, mas o Antigravity vai bloquear e forçar uma revisão do usuário porque rm não está na lista de permissões. O Antigravity precisa pedir sua permissão antes de executar o comando.

Observação:talvez seja necessário reiniciar o Antigravity para que a lista de permissão entre em vigor.

Configurar a lista de bloqueio

A lista de bloqueio é a proteção para a política do Turbo (e às vezes do Automático). Ele representa um modelo de segurança negativo, ou seja, tudo é permitido, a menos que seja expressamente proibido. Isso depende de o desenvolvedor antecipar todos os perigos possíveis, o que é uma proposta arriscada, mas que oferece velocidade máxima.

Configuração detalhada

1. Defina a configuração Execução automática de comandos do terminal como Turbo.
2. Adicione os seguintes comandos em Comandos do terminal da lista de bloqueio clicando no botão Adicionar ao lado.
3. rm
4. rmdir
5. sudo
6. curl
7. wget

Como testar a lista de bloqueio

• Pergunte ao agente: Check the version of python.
• O agente executa python --version automaticamente.
• Pergunte ao agente: Download www.google.com home page.
• O agente tenta curl. O Antigravity detecta curl na lista de bloqueio e impede a execução, pedindo sua aprovação manual.

Observação:talvez seja necessário reiniciar o Antigravity para que a lista de bloqueio entre em vigor.

Segurança do navegador

A capacidade de navegar na Web é um superpoder, mas também uma vulnerabilidade. Um agente que visita um site de documentação comprometido pode encontrar um ataque de injeção de comandos.

Para evitar isso, implemente uma lista de permissões de URL do navegador para o agente do navegador.

Para conferir suas configurações atuais, acesse Antigravity — Settings e depois Advanced Settings. Você vai encontrar a seção "Lista de permissões de URL do navegador" nas configurações do navegador, como mostrado abaixo:

Clique em "Abrir arquivo de lista de permissões", que abre o arquivo na pasta HOME/.gemini/antigravity/browserAllowlist.txt.. Assim, você garante que apenas domínios confiáveis sejam inseridos.

11. Casos de uso

Agora que temos uma compreensão básica do produto, vamos analisar alguns casos de uso para ver como ele funciona. O Antigravity é uma plataforma focada em agentes. Isso significa que, na maioria dos casos, estamos apenas uma instrução ao agente, que então realiza a tarefa, pede permissões se necessário, produz os artefatos e nos notifica quando a tarefa é concluída. Por isso, não podemos produzir todas as respostas da conversa do agente em cada um dos casos de uso a seguir. Vamos compartilhar as instruções e algumas capturas de tela necessárias dos resultados esperados, mas seus resultados podem ser um pouco diferentes.

Os casos de uso que vamos abordar variam desde a automação de algumas tarefas com sites externos até a geração e verificação de casos de teste de unidade para um projeto e o desenvolvimento completo de um site. Vamos lá.

Destaques de notícias

Este é um caso de uso simples, mas pode ser a base para usar o navegador da Web para visitar sites, extrair informações, realizar algumas ações e retornar dados ao usuário.

Neste caso, vamos acessar o site do Google Notícias e extrair algumas informações de lá. Mas você pode testar um site da sua escolha e ver como funciona.

Verifique se você está em Agent Manager e selecionou Playground, conforme mostrado abaixo:

Em seguida, dê a seguinte instrução:

Isso vai iniciar o processo do agente e determinar que ele precisa iniciar o navegador etc. Preste atenção ao processo de pensamento e veja como o agente realiza o trabalho. Se tudo der certo, o navegador Antigravity será aberto e vai acessar o site, conforme mostrado abaixo. A borda azul ao redor do site mostra que o agente agora está controlando o navegador e navegando pelo site para receber as informações.

Quando terminar, você também vai ver os artefatos sendo gerados, conforme mostrado abaixo:

Confira abaixo um exemplo de execução pelo agente:

À esquerda, temos o processo de pensamento. Você também pode rolar pelos pontos e ver a reprodução e outros dados.

O que testar

• Depois de entender isso, escolha um site disponível e de onde você quer que o agente acesse/resuma alguns dados. Pense em um site que você sabe que tem painéis e gráficos e peça para ele escolher alguns valores.
• Tente o seguinte comando: Visit https://docs.cloud.google.com/release-notes and get me a summary of the release notes, categorized by product.

Gerar um site dinâmico com Python e Flask

Agora vamos gerar um aplicativo da Web completo. O aplicativo da Web que vamos criar é um site que fornece informações sobre um evento técnico de um dia, com palestras de vários palestrantes ao longo do dia.

Mais uma vez, verifique se você está em Agent Manager e selecionou Playground.

Dê o seguinte comando:

I would like to generate a website that is a 1-day technical conference informational site.

The website should have the following functionality:
        1. A home page that shows the current date, location, schedule and time table.
        2. The 1-day event is a list of 8 talks in total.
        3. Each talk has 1 or 2 max. speakers. 
        4. A talk has an ID, Title, Speakers, Category (1 or 2), Description and time of the talk.
        5. Each speaker has a First Name, Last Name and LinkedIn url.
        6. Allow for users to search by category, speaker, title.
        7. Give a lunch break of 60 minutes.
        8. Use dummy data for events and speakers, come up with a schedule, the event is about Google Cloud Technologies.
        9. Tech Stack: Python and Flask framework on server side. Front-end is basic HTML, CSS and JavaScript. 
        10. Test out the site on your own for all functionality and provide a detailed README on how to setup, run and make any further changes. 
11. Launch the web application for me to review. 

Você pode iniciar a conversa com o comando acima:

À medida que o agente realiza a tarefa, ele cria os artefatos:

• Artefato de tarefa
• Artefato de implementação
• Artefato de tutorial

O artefato de tarefa abaixo foi a sequência inicial de tarefas que o agente decifrou que deveria fazer com base na tarefa atribuída a ele. Confira abaixo uma captura de tela de exemplo da execução:

Em seguida, clique no artefato Plano de implementação. Confira abaixo uma captura de tela de exemplo:

Por fim, há o artefato Tutorial. Ele contém tudo o que o agente fez, conforme mostrado abaixo:

Ele iniciou o servidor e me forneceu o URL. Clique nele para acessar o aplicativo. Confira abaixo uma captura de tela de exemplo:

Se eu mudar para o Editor, observe na tela que ele contém a pasta em que o aplicativo Python Flask é gerado. Você também vai notar que o Agent mode está marcado à direita, e você pode continuar a conversa por lá também.

Agora, digamos que queremos adicionar mais palestras ao evento. Podemos ficar no Editor e no painel do agente e dar um comando como Add two more talks to the schedule.

Isso vai fazer com que o agente analise o requisito, atualize a tarefa, o plano de implementação e valide a funcionalidade atualizada. Confira um exemplo de conversa abaixo:

Se quiser, você pode voltar para o Gerenciador de agentes. Esse processo ajuda você a entender a transição do Gerente de agente para o Editor, fazer as mudanças necessárias e assim por diante.

Observação:ao executar essa tarefa, o agente tentou iniciar o servidor Flask na porta 5000, que estava em uso na máquina atual. Ele tentou a próxima porta livre até decidir usar 8080 e conseguiu iniciar o servidor.

O que testar

• Adicione outras funcionalidades que você quer ao aplicativo. Forneça os detalhes ao agente e observe como ele realiza a tarefa, primeiro modificando a lista de tarefas, depois o plano de implementação e assim por diante.
• Peça ao agente para gerar um README ou mais documentação para o aplicativo.

Gerar um app de produtividade simples

Agora vamos gerar um aplicativo da Web simples de timer Pomodoro.

Verifique se você está no Agent Manager e selecionou o Playground. Dê o seguinte comando:

Create a productivity app that features a Pomodoro timer. Give a calm and aesthetic look to the application.

Observe como ele cria a lista de tarefas, o plano de implementação e depois segue em frente. Continue prestando atenção ao fluxo, porque pode haver situações em que ele vai pedir sua revisão. Confira abaixo um exemplo de execução.

Nesse caso, ele também precisa iniciar o navegador Antigravity, fazer os próprios testes e confirmar que eles foram concluídos. Uma das coisas que ele gerou foi um artefato de mídia que contém o vídeo da verificação. Essa é uma ótima maneira de ver o que foi testado. Também sugeri algumas mudanças de estilo, já que elas não entraram em vigor, e a IA conseguiu fazer isso.

O app final ficou parecido com o abaixo e ficou muito bom.

Que tal adicionar uma imagem de timer ao aplicativo? Basta emitir uma instrução de acompanhamento, conforme mostrado abaixo:

Add an image to the application that displays a timer.

Isso fez com que o agente adicionasse uma nova tarefa ao artefato de tarefa:

Em seguida, ele gerou uma imagem ao realizar a tarefa:

Por fim, o app tinha a imagem conforme solicitado:

O que testar

• O plano de fundo do ícone de ampulheta no aplicativo não é transparente. Tente pedir para o agente deixar isso transparente.
• Teste algumas variações de qualquer aplicativo que você queira gerar. Brinque com os estilos, imagens, peça mudanças etc.

Gerar testes de unidade, stubs simulados e validar testes

O último caso de uso que vamos testar aqui é a geração de testes de unidade para um arquivo de código específico que temos e para o agente executar e validar os testes.

Para isso, vamos ter um espaço de trabalho com um único arquivo Python, como mostrado abaixo:

from typing import Dict

# --- Custom Exceptions ---
class InventoryShortageError(Exception):
    """Raised when there is not enough item stock."""
    pass

class PaymentFailedError(Exception):
    """Raised when the payment gateway rejects the transaction."""
    pass

class InvalidOrderError(Exception):
    """Raised when the order violates business rules."""
    pass

# --- External Service Interfaces (To be Mocked) ---
class InventoryService:
    def get_stock(self, product_id: str) -> int:
        """Connects to DB to check stock."""
        raise NotImplementedError("Real connection required")

    def decrement_stock(self, product_id: str, quantity: int):
        """Connects to DB to reduce stock."""
        raise NotImplementedError("Real connection required")

class PaymentGateway:
    def charge(self, amount: float, currency: str) -> bool:
        """Connects to Stripe/PayPal."""
        raise NotImplementedError("Real connection required")

# --- Main Business Logic ---
class Order:
    def __init__(self, 
                 inventory_service: InventoryService, 
                 payment_gateway: PaymentGateway,
                 customer_email: str,
                 is_vip: bool = False):
        
        self.inventory = inventory_service
        self.payment = payment_gateway
        self.customer_email = customer_email
        self.is_vip = is_vip
        self.items: Dict[str, Dict] = {} # {product_id: {'price': float, 'qty': int}}
        self.is_paid = False
        self.status = "DRAFT"

    def add_item(self, product_id: str, price: float, quantity: int = 1):
        """Adds items to the cart. Rejects invalid prices or quantities."""
        if price < 0:
            raise ValueError("Price cannot be negative")
        if quantity <= 0:
            raise ValueError("Quantity must be greater than zero")

        if product_id in self.items:
            self.items[product_id]['qty'] += quantity
        else:
            self.items[product_id] = {'price': price, 'qty': quantity}

    def remove_item(self, product_id: str):
        """Removes an item entirely from the cart."""
        if product_id in self.items:
            del self.items[product_id]

    @property
    def total_price(self) -> float:
        """Calculates raw total before discounts."""
        return sum(item['price'] * item['qty'] for item in self.items.values())

    def apply_discount(self) -> float:
        """
        Applies business logic:
        1. VIPs get flat 20% off.
        2. Regulars get 10% off if total > 100.
        3. No discount otherwise.
        """
        total = self.total_price
        
        if self.is_vip:
            return round(total * 0.8, 2)
        elif total > 100:
            return round(total * 0.9, 2)
        
        return round(total, 2)

    def checkout(self):
        """
        Orchestrates the checkout process:
        1. Validates cart is not empty.
        2. Checks stock for all items.
        3. Calculates final price.
        4. Charges payment.
        5. Updates inventory.
        """
        if not self.items:
            raise InvalidOrderError("Cannot checkout an empty cart")

        # 1. Check Inventory Logic
        for product_id, data in self.items.items():
            available_stock = self.inventory.get_stock(product_id)
            if available_stock < data['qty']:
                raise InventoryShortageError(f"Not enough stock for {product_id}")

        # 2. Calculate Final Price
        final_amount = self.apply_discount()

        # 3. Process Payment
        try:
            success = self.payment.charge(final_amount, "USD")
            if not success:
                raise PaymentFailedError("Transaction declined by gateway")
        except Exception as e:
            # Catching generic network errors from the gateway
            raise PaymentFailedError(f"Payment gateway error: {str(e)}")

        # 4. Decrement Stock (Only occurs if payment succeeded)
        for product_id, data in self.items.items():
            self.inventory.decrement_stock(product_id, data['qty'])

        self.is_paid = True
        self.status = "COMPLETED"
        
        return {"status": "success", "charged_amount": final_amount}

Verifique se você tem o arquivo Python acima localmente em uma pasta e carregue-o como um espaço de trabalho no Antigravity.

Este é um serviço de pedidos simples que tem a seguinte funcionalidade principal na função checkout:

1. Valida se o carrinho não está vazio.
2. Verifique o estoque de todos os itens.
3. Calcula o preço final.
4. Cobrança do pagamento.
5. Atualiza o inventário.

Vamos atribuir ao agente a tarefa de gerar casos de teste de unidade, fornecer implementações de simulação e executar os testes para garantir que eles sejam bem-sucedidos.

Vamos abrir a pasta específica do espaço de trabalho. Você vai notar que agora também podemos usar o símbolo @ para referenciar o arquivo. Por exemplo, podemos fazer o seguinte:

Isso aparece com alguma explicação sobre o que é esse arquivo:

Podemos pedir para gerar uma visualização melhor usando o comando:

Can you visually show this class for better understanding

A próxima etapa é gerar os testes de unidade e pedir ao agente para testá-los. Dou o seguinte comando:

generate unit tests for this module and test it out with mock implementations.

Ele gerou o seguinte artefato de tarefa e seguiu com a tarefa.

Você também pode conferir os detalhes dos testes executados:

Um dos arquivos gerados também era o arquivo de teste. Confira uma captura de tela abaixo:

O que testar

Pegue seu próprio código e veja o que você pode pedir ao agente, desde adicionar mais funcionalidades até refatorar partes do código.

12. Parabéns

Parabéns! Você instalou e entendeu como usar o Antigravity, a plataforma de desenvolvimento focada em agentes. Os diferentes casos de uso que testamos podem ajudar você a entender seus próprios requisitos e descobrir como o Antigravity pode colaborar para atendê-los.

Documentos de referência

• Site oficial : https://antigravity.google/
• Documentação: https://antigravity.google/docs
• Casos de uso : https://antigravity.google/use-cases
• Download : https://antigravity.google/download
• Canal do YouTube do Google Antigravity : https://www.youtube.com/@googleantigravity