Introdução ao Google Antigravity

1. Introdução

Neste codelab, você vai aprender sobre o Google Antigravity (chamado de Antigravity no restante do documento), uma plataforma de desenvolvimento agêntico que evolui o IDE 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. Ela 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 de engenharia complexas 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.
Personalizar o Antigravity com suas próprias regras e fluxo de trabalho, além de considerações de segurança.

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 premium.

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 do terminal

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

Sempre continuar:sempre executa automaticamente os comandos do terminal, exceto aqueles em uma lista de bloqueio configurável.
Solicitar revisão:pede 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 as políticas de execução, revisão e execução de JavaScript do terminal 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 o nível de autonomia que 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ões (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 Antigravidade 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 agentes

Tudo pronto para começar!

O Antigravity bifurca a 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 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 gerem, 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 com 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 haver preocupação 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 Agent Manager é mostrada abaixo:

Consulte o diagrama acima com os números:

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.
Start Conversation: clique aqui para iniciar uma nova conversa. Isso vai levar você diretamente à entrada onde está escrito Ask anything.
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.
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.
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.
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 Antigravity 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 "Antigravidade", 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 para:

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 diferenças 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 ver 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 por aqui.

7. Editor

O editor mantém a familiaridade do VS Code, garantindo que a memória muscular de 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 codificaçã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. Mais importante ainda, eles também são uma maneira 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 a 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 ao 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.

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. O 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. Habilidades

Embora os modelos da Antigravity (como o Gemini) sejam generalistas poderosos, eles não conhecem o contexto específico do seu projeto nem os padrões da equipe . Carregar todas as regras ou ferramentas na janela de contexto do agente causa "excesso de ferramentas", custos mais altos, latência e confusão.

As habilidades de antigravidade resolvem isso com a divulgação progressiva. Uma habilidade é um pacote especializado de conhecimento que fica inativo até ser necessário. Ele só é carregado no contexto do agente quando sua solicitação específica corresponde à descrição da habilidade .

Estrutura e escopo

As habilidades são pacotes baseados em diretórios. É possível defini-los em dois escopos, dependendo das suas necessidades:

Escopo global (~/.gemini/antigravity/skills/): disponível em todos os seus projetos (por exemplo, "Format JSON", "General Code Review") .
Escopo do espaço de trabalho (<workspace-root>/.agent/skills/): disponível apenas em um projeto específico (por exemplo, "Implantar no preparo deste app", "Gerar boilerplate para este framework específico") .

Anatomia de uma habilidade

Um diretório de habilidades típico tem esta aparência :

my-skill/
├── SKILL.md    #(Required) metadata & instructions.
├── scripts/    # (Optional) Python or Bash scripts for execution.
├── references/ # (Optional) text, documentation, or templates.
└── assets/     # (Optional) Images or logos.

Agora vamos adicionar algumas habilidades.

Habilidade de revisão de código

Esta é uma skill somente de instruções. Ou seja, só precisamos criar o arquivo SKILL.md, que vai conter os metadados e as instruções da skill. Vamos criar uma habilidade global que forneça detalhes ao agente para revisar mudanças no código em busca de bugs, problemas de estilo e práticas recomendadas.

Primeiro, crie o diretório que vai conter essa habilidade global.

mkdir -p ~/.gemini/antigravity/skills/code-review

Crie um arquivo SKILL.md no diretório acima com o conteúdo mostrado abaixo:

---
name: code-review
description: Reviews code changes for bugs, style issues, and best practices. Use when reviewing PRs or checking code quality.
---

# Code Review Skill

When reviewing code, follow these steps:

## Review checklist

1. **Correctness**: Does the code do what it's supposed to?
2. **Edge cases**: Are error conditions handled?
3. **Style**: Does it follow project conventions?
4. **Performance**: Are there obvious inefficiencies?

## How to provide feedback

- Be specific about what needs to change
- Explain why, not just what
- Suggest alternatives when possible

O arquivo SKILL.md acima contém os metadados (nome e descrição) na parte superior e depois as instruções. Ao ser carregado, o agente só lê os metadados das habilidades que você configurou e carrega as instruções da habilidade apenas se necessário.

Faça um teste

Crie um arquivo chamado demo_bad_code.py com o conteúdo mostrado abaixo:

import time

def get_user_data(users, id):
   # Find user by ID
   for u in users:
       if u['id'] == id:
            return u
   return None

def process_payments(items):
   total = 0
   for i in items:
       # Calculate tax
       tax = i['price'] * 0.1
       total = total + i['price'] + tax
       time.sleep(0.1) # Simulate slow network call
  
   return total

def run_batch():
   users = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
   items = [{'price': 10}, {'price': 20}, {'price': 100}]
  
   u = get_user_data(users, 3)
   print("User found: " + u['name']) # Will crash if None
  
   print("Total: " + str(process_payments(items)))

if __name__ == "__main__":
   run_batch()

Pergunte ao agente: review the @demo_bad_code.py file. O agente precisa identificar a habilidade code-review, carregar os detalhes e realizar a ação de acordo com as instruções fornecidas no arquivo code-review/SKILL.md.

Confira um exemplo de saída abaixo:

A skill de modelo de cabeçalho de código

Às vezes, uma skill precisa usar um grande bloco de texto estático, como um cabeçalho de licença. Colocar esse texto diretamente no comando é um desperdício. Em vez disso, colocamos em uma pasta resources/ e instruímos o agente a ler apenas quando necessário .

Primeiro, crie o diretório que vai conter essa habilidade do espaço de trabalho.

mkdir -p .agent/skills/license-header-adder/resources

Crie .agent/skills/license-header-adder/resources/HEADER.txt com o texto da sua licença:

/*
 * Copyright (c) 2026 YOUR_COMPANY_NAME LLC.
 * All rights reserved.
 * This code is proprietary and confidential.
 */

Crie um arquivo .agent/skills/license-header-adder/SKILL.md com o conteúdo mostrado abaixo:

---
name: license-header-adder
description: Adds the standard corporate license header to new source files.
---

# License Header Adder

This skill ensures that all new source files have the correct copyright header.

## Instructions
1. **Read the Template**: Read the content of `resources/HEADER.txt`.
2. **Apply to File**: When creating a new file, prepend this exact content.
3. **Adapt Syntax**: 
   - For C-style languages (Java, TS), keep the `/* */` block.
   - For Python/Shell, convert to `#` comments.

Faça um teste

Pergunte ao agente: Create a new Python script named data_processor.py that prints 'Hello World'.

O agente vai ler o modelo, converter os comentários no estilo C para o estilo Python e adicionar automaticamente ao início do novo arquivo.

Ao criar essas habilidades, você transformou o modelo generalista do Gemini em um especialista para seu projeto. Você codificou suas práticas recomendadas, seja seguindo as diretrizes de revisão de código ou os cabeçalhos de licença. Em vez de pedir repetidamente para a IA "lembrar de adicionar a licença" ou "corrigir o formato do commit", o agente agora sabe instintivamente como trabalhar com sua equipe.

11. 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 internos de segurança. 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ão é 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

Defina a opção Execução automática de comandos do terminal como Desativada.
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ão. O Antigravity precisa pedir sua permissão antes de executar o comando.

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

Defina a configuração Execução automática de comandos do terminal como Turbo.
Adicione os seguintes comandos em Comandos do terminal da lista de bloqueio clicando no botão Adicionar ao lado.
rm
rmdir
sudo
curl
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.

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 URLs 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 vai abrir o arquivo na pasta HOME/.gemini/antigravity/browserAllowlist.txt.. Verifique se apenas domínios confiáveis foram inseridos.

12. Conclusão e próximas etapas

Parabéns! Você instalou o Antigravity, configurou seu ambiente e aprendeu a controlar seus agentes.

A seguir Para ver o Antigravity em ação na criação de aplicativos do mundo real, incluindo um site dinâmico de conferência e um app de produtividade, acesse o próximo codelab : Como criar com o Google Antigravity.

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