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 de agentes que evolui o ambiente de desenvolvimento integrado para a era de agentes em primeiro lugar.

Ao contrário dos assistentes de programação padrão que apenas preenchem linhas automaticamente, o Antigravity oferece uma "Central de comando" 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 "agente em primeiro lugar". 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

1. Instalar e configurar o Antigravity
2. Conheça os principais conceitos do Antigravity, como Agent Manager, Editor, Browser e muito mais.
3. 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 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, incluindo iniciantes.

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 Próxima a cada vez. Confira abaixo as principais etapas:

• Choose setup flow: Isso abre a opção de importar das configurações atuais do VS Code ou do Cursor. Vamos começar do zero.
• Choose an Editor theme type. Vamos usar o tema escuro, mas a escolha é sua, dependendo da sua preferência.
• How do you want to use Antigravity agent:

Vamos entender isso com mais detalhes e lembrar que não é algo fixo e pode ser mudado a qualquer momento, mesmo durante a interação com o agente.

Antes de analisarmos as opções, vamos conferir duas 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. Há três opções aqui.

• Off: nunca execute comandos do terminal automaticamente, exceto aqueles em uma lista de permissão configurável.
• Auto: o agente decide se executa automaticamente um comando de terminal específico. Se precisar da sua permissão, ele vai decidir e pedir.
• Turbo: sempre execute comandos do terminal automaticamente, exceto aqueles em uma lista de bloqueio configurável.

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.

• Always Proceed: o agente nunca pede uma avaliação
• Agent Decides: o agente vai decidir quando pedir uma revisão.
• Request Review: o agente sempre pede uma revisão

Agora que entendemos isso, as quatro opções são apenas predefinições específicas para a execução do terminal e políticas de revisão para três delas, além de 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:

• Desenvolvimento orientado a agentes
• Desenvolvimento assistido por agente
• Desenvolvimento orientado a revisões
• Configuração personalizada

A opção de desenvolvimento assistido por agente é 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.

Escolha a opção que preferir e, por enquanto, vamos usar a abordagem recomendada.

• Configure your Editor: escolha suas preferências.
• Sign in to 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. Verifique se um novo perfil do Chrome foi criado para isso. Isso vai abrir o navegador para que você faça 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.
• Terms of Use: decida se você quer ativar ou não e clique em Próxima.

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

3. O gerente de agentes

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: o Editor e o Gerenciador de agentes. Essa separação de responsabilidades reflete a distinção entre contribuição individual e gerenciamento de engenharia.

O Agent Manager: 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 criem, monitorem e interajam com vários agentes que operam 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, que eram lineares e síncronos. 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 Próxima acima, poderá abrir um espaço de trabalho.

Pense no Workspace 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 no diretório principal chamada my-agy-projects e selecionei essa opção. Você pode usar uma pasta completamente diferente.

Se quiser, você pode pular essa etapa 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:

Você vai notar que o aplicativo está imediatamente pronto para iniciar uma nova conversa na pasta do espaço de trabalho (my-agy-projects) selecionada. Você pode usar seu conhecimento atual de 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 nos agentes, pense nisso como a capacidade de controlar o pensamento do agente, afetando diretamente o 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 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 com a mensagem 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. Como configurar o 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. O agente vai analisar a tarefa, e você 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 Configurar.

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:

Como inspecionar os artefatos

Agora vem a parte interessante. Quando o agente terminar o trabalho, você poderá ver tudo o que ele fez. Isso traz artefatos, a base em que você constrói sua confiança em termos de trabalho planejado, o que você fez até agora e como você verificou isso.

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.

O Antigravity se concentra na produção de artefatos importantes, dependendo da tarefa. Isso pode variar do plano de tarefas ao plano de implementação e, finalmente, ao plano de tutorial (com verificação). Nesses planos, considere ter itens como:

• Task Lists & Plans: antes de escrever o código, o agente gera um plano estruturado. O usuário pode analisar, editar e aprovar esse plano.
• Code Diffs: visualizações de diferenças padronizadas que mostram exatamente quais linhas vão mudar.
• 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.
• Test Results: registros estruturados de testes aprovados/com falha gerados e executados pelo agente.

No canto superior direito, ao lado de "Revisar mudanças na visualização do Gerenciador de agentes", você vai encontrar um botão para ativar/desativar os artefatos. Se ele estiver ativado, você vai ver a lista de artefatos gerados:

Você vai ver a visualização "Artifacts" (Artefatos), como mostrado abaixo. Neste caso, instruímos o agente a acessar a página antigravity.google. Por isso, ele capturou a captura de tela, criou um vídeo dela etc.

Os desenvolvedores podem interagir com esses artefatos 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 os Documentos Google interativos, em que você dá feedback ao autor, e ele faz uma nova versão com base nisso.

5. Revisitar a Caixa de entrada

Se você já iniciou algumas conversas com os agentes, confira sua caixa de entrada na janela do Gerenciador de agentes. 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.

6. The 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 Abrir editor no canto superior direito do Gerenciador de agentes para acessar o editor.

O Editor é aprimorado com a "Percepção do agente".

• Inline Command: o editor oferece suporte à programação de vibe e instruções inline, em que os usuários podem destacar o código e instruir o agente a "Make this more efficient" ou "Add comments explaining this logic".
• Agent Side Panel : use o painel no lado direito do editor para trabalhar diretamente com o agente. Você pode iniciar novas conversas ou dar instruções para mudar seu código.

Ao analisar alguns casos de uso relacionados ao desenvolvimento da Web, em que o agente cria vários arquivos de código, podemos conferir o editor para ver os arquivos, fazer mudanças e interagir diretamente com o agente.

7. Alternar entre o Editor e o Gerenciador de agentes

A Antigravity entende que o Editor e o Gerenciador de agentes são janelas separadas e que ambos são necessários. Você pode alternar entre um e outro usando o botão Abrir o Gerenciador de agentes no canto superior direito do Editor ou clicando no botão Abrir o Editor no canto superior direito do Gerenciador de agentes.

Como alternativa, você também pode usar o seguinte atalho de teclado para alternar entre os dois modos: Cmd + E

8. 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 que prioriza o agente. Isso significa que, na maioria dos casos, recebemos apenas uma instrução para o 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 seguintes casos de uso. 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.

Nesse 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 e 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.

Envie 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 começar 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 uma instrução 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 continuou tentando 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. Envie o seguinte comando:

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

Perceba 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 não surtiram efeito, e o Gemini conseguiu fazer isso.

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

Que tal adicionar uma imagem de timer legal 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 "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ças de 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 uma explicação do 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.

9. Parabéns

Parabéns! Você instalou e entendeu como usar o Antigravity, a plataforma de desenvolvimento com foco 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