Google Antigravity: construindo software com agentes de IA autônomos

Ambientes e ferramentas - Apresentação

Apresentando o curso e a ferramenta

Boas-vindas a mais um curso da Alura sobre Antigravity.

Neste curso, vamos aprender sobre esta ferramenta recentemente lançada, em sua versão 2.0: o Antigravity do Google.

Comparando a versão 2.0 e planejando o projeto

Estamos com a ferramenta aberta. Se já tivermos usado o Antigravity antes desta atualização, a interface pode parecer diferente. Na versão 2.0, o Google separou a experiência de interação com agentes — que é esta interface, o Antigravity 2.0, também chamado de Agent Manager — da experiência de IDE (ambiente de desenvolvimento integrado), que continua existindo e permanece mais parecida com o que já tínhamos antes, mas agora utiliza uma stack (pilha) diferente, a da 2.0. Essa experiência de conversação é mais próxima do que vemos no Codex e no Cloud Code.

Para explorarmos esta ferramenta e analisarmos suas funcionalidades, nós vamos criar o projeto de nossa agência de aluguel. Nele, teremos os carros disponíveis para alugar, poderemos filtrá-los, visualizar seus detalhes e calcular o total do aluguel conforme as datas, também considerando o plano de proteção. Tudo o que adicionarmos ao carrinho de compras da agência será contemplado, com autenticação por login e cadastro na interface.

Conectando serviços e definindo próximos passos

Tudo será implementado com o Antigravity, conectado ao Supabase e ao nosso Figma. Teremos o Figma como servidor MCP, o Supabase também como servidor MCP, e trabalharemos dentro do Antigravity para gerar esse site e construir a ferramenta que permitirá realizar locações e desenvolver nosso negócio.

Vamos explorar todas essas etapas, conhecer diversas funcionalidades do Antigravity e entender como a versão 2.0 se diferencia da anterior. Também faremos comparações com o Codex, com o Cloud Code e com outras ferramentas de interface e assistentes de programação, observando como funcionam atualmente e quais são as boas práticas para trabalhar em conjunto com uma ferramenta desse tipo.

Vamos?

Ambientes e ferramentas - Conhecendo a stack de ferramentas

Apresentando o conjunto de ferramentas Antigravity

Para iniciar este curso de Antigravity, estamos com a plataforma aberta para discutirmos quais são as ferramentas de Antigravity que realmente vamos utilizar. Costuma-se chamar tudo de Antigravity, e o Google inclusive denomina Antigravity 2.0, a ferramenta Antigravity, mas, na prática, foi criado um conjunto de ferramentas.

Estamos no site, que traz toda a parte de explicação e divulgação, com bastante destaque para Antigravity 2.0. Também podemos ver que há um CLI (interface de linha de comando), um SDK (kit de desenvolvimento de software) para criação de agentes e uma IDE (ambiente de desenvolvimento integrado). Portanto, dentro do que chamamos Antigravity, temos quatro possíveis ferramentas para utilizar e, na seção de produto, há a lista dos quatro produtos diferentes:

• Antigravity 2.0, que vamos usar bastante neste curso;
• Antigravity CLI, uma ferramenta especializada para a linha de comando;
• Antigravity IDE, que também vamos usar neste curso;
• SDK, uma ferramenta para a criação de agentes de IA, específica para configurar agentes que serão executados usando esse SDK.

Definindo as ferramentas do curso e configurando o LLM

No curso, como dissemos, utilizaremos duas ferramentas: o que está sendo chamado de Antigravity 2.0 e o Antigravity IDE. Já deixamos Antigravity 2.0 aberto. Essa ferramenta é muito parecida com o Codex ou com o Cloud Code; se você já usou algum dos dois, irá se familiarizar rapidamente com Antigravity 2.0, porque, no fim, é um harness (ferramenta de orquestração) que nos ajuda a nos comunicarmos com o LLM (modelo de linguagem grande).

Nesse caso, já está selecionado o LLM Gemini 3.5 Flash, mas também podemos ajustar o nível de raciocínio do modelo: Medium (médio), High (alto) ou Low (baixo), ou seja, três níveis de raciocínio diferentes dentro desse mesmo modelo de linguagem. Alternativamente, podemos usar o Gemini 3.1 Pro, com Low (baixo) ou High (alto), com mais ou menos processamento e, consequentemente, mais ou menos raciocínio no momento em que o modelo é executado.

Detalhando o harness e a IDE

Antigravity 2.0 é a interface do harness (arcabouço), oferecendo uma experiência muito parecida com Cloud Code ou Codex. É um harness orientado a código; embora traga várias funcionalidades que poderíamos usar no dia a dia em gestão de pessoas, criação de documentos e documentação de processos, é uma ferramenta pensada para pessoas desenvolvedoras, para quem vai escrever código. Ela está acoplada à IDE: há um botão na parte superior para abrir a IDE, que é claramente focada em desenvolvimento e que também vamos utilizar.

Temos a Antigravity IDE que, em dezembro, quando foi lançado o beta, era basicamente o que existia. A IDE é muito similar ao VS Code: contamos com o Explorador do projeto, a barra de busca, integração com o GitHub e extensões, ou seja, tudo o que o VS Code oferece. Além disso, ela inclui o componente de agente conectado ao nosso harness, com uma janela de conversas do agente integrada ao Antigravity. Também há outros recursos nessa IDE. Portanto, teremos a IDE que vamos usar e o Antigravity 2.0; essas são as duas ferramentas que vamos utilizar no conjunto de ferramentas do Antigravity neste curso.

Configurando o projeto e articulando o uso entre harness e IDE

Além disso, vamos configurar e exemplificar o uso dessa ferramenta com este projeto, o projeto da Ermex, uma empresa de aluguel de veículos, que já está aberto aqui. Vamos simular e criar esse projeto para observar quais funcionalidades chegaram ao Antigravity 2.0 e como ficou a experiência separada entre a IDE e o harness, porque agora é possível usar ambos de forma independente, algo que antes não era possível. Para isso, também vamos usar o Supabase. Para não termos que criar duas bases de código — o front-end e o back-end — vamos utilizar uma ferramenta de back-end como serviço, o Supabase. Essa será a nossa combinação de ferramentas.

A principal diferença a considerar ao falar de Antigravity 2.0 é que o Google se refere, com Antigravity 2.0, à interface do harness, uma interface na qual não temos acesso direto ao código. Basicamente, teremos todas as conversas com a nossa LLM e com o agente, e esse agente vai dialogar conosco e modificar o projeto em nosso lugar. Isso proporciona uma experiência diferente da IDE, onde temos acesso a todo o projeto e podemos editar o código diretamente. Portanto, são duas experiências distintas.

Vamos trabalhar com ambas em paralelo, buscando extrair o máximo das funcionalidades que esse harness oferece e, quando necessário, mostraremos na IDE — caso você esteja mais acostumade e queira continuar o trabalho por lá — onde as coisas estão, para executar as tarefas de forma mais manual, sem depender do funcionamento do harness. É isso que faremos neste curso: explorar essas ferramentas, entender suas funções e como podemos obter o melhor proveito de tudo isso.

Ambientes e ferramentas - Configurando MCPs

Iniciando o projeto e configurando o antigravity

Vamos começar nosso projeto e, para isso, primeiro precisaremos configurar o antigravity. Para iniciar, vamos selecionar a nossa pasta de projetos, isto é, a pasta no computador que usaremos.

Se você já utilizou o Cloud Coach ou o Codecs, ou algum outro tipo de harness (orquestrador), este passo será familiar. Precisaremos selecionar uma pasta dentro da máquina e conceder acesso ao harness, ao antigravity, para que funcione com permissão de edição e manipulação dos arquivos daquela pasta.

Criando um novo projeto e destacando diferenças

Vamos criar um novo projeto. Podemos selecionar uma pasta própria ou optar pelo quickstart (início rápido), que cria uma pasta padrão com um nome aleatório ou pseudoaleatório dentro de uma pasta padrão do antigravity. No nosso caso, vamos criar um novo projeto porque já sabemos qual projeto queremos desenvolver.

Aqui encontramos a primeira grande diferença do antigravity em relação a outros harnesses (orquestradores). Em soluções como o Codecs ou o Cloud Coach, cada projeto equivale a uma única pasta principal à qual concedemos acesso. No antigravity, como ele é pensado para desenvolvimento, e é comum separarmos back-end (camada de servidor), front-end (camada de interface), especificação e DevOps (desenvolvimento e operações) em repositórios Git (sistema de controle de versão) e pastas diferentes, ele permite selecionar mais de uma pasta no momento de criar o projeto.

Adicionando múltiplas pastas e organizando repositórios

Primeiro, vamos adicionar uma pasta, selecionando no computador o local onde ficará o código. Teremos uma pasta chamada "remax" para o front-end (camada de interface) do sistema que vamos criar, e a selecionaremos. Se quisermos adicionar uma segunda pasta, também podemos. Vamos incluir uma segunda pasta, por exemplo, para a especificação do projeto. Assim, teremos duas pastas diferentes para trabalhar. Podemos ainda criar outra pasta para o back-end (camada de servidor). Criamos a pasta de back-end e concedemos acesso às três pastas.

É possível fazer algo semelhante em outras ferramentas? Sim, porém, normalmente, concederíamos acesso a uma pasta principal, a pasta raiz do projeto, e, dentro dela, manteríamos as subpastas de front-end, especificação e back-end, gerenciando tudo em um único diretório. Aqui, o antigravity já permite organizar por pastas distintas, independentemente de estarem ou não dentro da mesma pasta principal, o que é uma vantagem.

Ajustando pastas do projeto e definindo instruções

Vamos remover uma das pastas e manter "remax" e "especificação" como as duas pastas com as quais vamos trabalhar. Em seguida, clicamos em Seguinte. O nome do projeto é definido automaticamente a partir do nome da pasta, o que está adequado. Criamos o projeto e, à primeira vista, quase nada muda na interface. Na parte superior, vemos o projeto em que estamos trabalhando e podemos, a partir dali, criar um novo projeto ou optar por uma conversa individual, sem projeto associado.

No entanto, ainda não está indicado em qual pasta trabalharemos dentro deste projeto. Precisaremos configurar isso para especificar e identificar a função de cada pasta, algo muito comum quando trabalhamos com harnesses (orquestradores). Teremos um arquivo de instruções que vamos criar para o nosso projeto.

Adicionando MCPs e configurando a Supabase

Aproveitando, vamos adicionar nossos MCPs (Protocolos de Contexto de Modelo). Para isso, vamos até as configurações, na seção de personalização, onde está a área dedicada aos MCPs (Protocolos de Contexto de Modelo).

Vamos adicionar um MCP. O primeiro será o da Supabase. Vamos adicioná-lo aqui e, em seguida, será solicitada uma autenticação. A mensagem informa que não foi possível inicializar porque falta autenticar. A instalação foi concluída, mas a autenticação não foi feita automaticamente. Nós clicamos no botão e será solicitado um código. Faremos isso fora do vídeo, porque esse código é secreto e não deve ser compartilhado com outras pessoas.

Configurando o Figma DevMode MCP e executando o servidor local

O outro MCP que vamos adicionar é o do Figma. Vamos utilizar o Figma DevMode MCP. Vamos adicioná-lo e ele também apresentará uma mensagem de erro. A mensagem está pequena na tela, então vamos ler: ocorreu um erro ao inicializar, uma requisição POST foi rejeitada e esse POST foi enviado para 127.0.0.1. Ou seja, diferentemente da Supabase, que tenta conectar ao servidor MCP remoto para obter as informações, o Figma tenta conectar ao servidor local do Figma. Portanto, precisamos criar esse servidor local ou alterar as configurações para utilizar o servidor remoto.

Para executar um servidor local do Figma, abrimos o aplicativo de desktop do Figma, já no nosso projeto, no caso, "MX". Pressionamos SHIFT+D para alternar para o modo de desenvolvimento. Nesse modo, aparece na lateral a seção MCP, na qual podemos habilitar o Desktop MCP Server. Habilitamos e, localmente, o servidor já está em execução. Se fizermos um refresh (atualizar), o Figma passa a funcionar, conectado ao nosso servidor local.

Concluindo a autenticação e configurando pela IDE

No caso da Supabase, precisamos obter o código de autenticação e fornecê-lo para que tudo funcione. Faremos isso fora do vídeo e, no próximo vídeo, a Supabase já estará configurada.

Se, em vez de usar o nosso harness (estrutura de suporte), que é o Antigravity 2.0, quisermos configurar pela IDE (Ambiente de Desenvolvimento Integrado), abrimos a IDE. Ao abrir, ela pergunta qual pasta queremos abrir; indicamos "remax", que é nosso front-end. A IDE abre a pasta e clicamos em OK. Na segunda tela, será perguntado se confiamos nessa pasta para abri-la.

Para configurar os MCPs por aqui, ao aparecer um erro de MCP, podemos clicar na mensagem e escolher Ver configurações de MCP. Também é possível pressionar Ctrl+P e digitar > MCP, MCP. Então aparecerá a opção Administrar servidores MCP. Ao entrar, veremos os dois: Supabase e Figma (já configurado). Nesse painel de Administrar MCPs, dentro da IDE do Antigravity, temos acesso aos dois arquivos de configuração.

Ajustando configurações dos MCPs e editando o arquivo bruto

No Figma (e em qualquer MCP), podemos visualizar o arquivo bruto (raw), onde é possível ver para onde a requisição está sendo enviada. Se quisermos enviar a requisição ao Figma remoto, basta alterar a URL de conexão para apontar para o servidor remoto.

Para ilustrar como esse arquivo bruto de configuração pode aparecer, veja um exemplo de conteúdo com os dois servidores configurados:

{
  "mcpservers": [
    {
      "serverUrl": "https://mcp.supabase.com/mcp",
      "name": "supabase"
    },
    {
      "name": "figma-dev-mode-mcp-server",
      "serverUrl": "http://127.0.0.1:1844/mcp"
    }
  ]
}

Observe que:

• O servidor da Supabase já aponta para um endpoint remoto (https://mcp.supabase.com/mcp), condizente com a necessidade de autenticação.
• O servidor do Figma aponta para o endereço local (http://127.0.0.1:1844/mcp). Para usar o Figma remoto, basta alterar o valor de serverUrl para o endpoint remoto apropriado; para usar localmente, mantenha essa URL e certifique-se de habilitar o Desktop MCP Server no app do Figma, como mostrado.

No caso da Supabase, está tudo certo; só precisamos realizar a autenticação. Mostramos também onde isso fica dentro da IDE para efetuarmos a configuração.

Sincronizando configurações e usando a paleta de comandos

Note que as duas camadas estão conectadas: ao ajustarmos no Antigravity 2.0, quando abrimos a IDE, ela já traz as mesmas configurações, com os mesmos erros, inclusive a mesma mensagem de erro da Supabase.

Novamente, Ctrl+P abre a barra. Como já utilizamos o comando nesta sessão, ele pode aparecer no histórico; caso contrário, '>' abre a paleta de comandos. Ao digitar manage e mcp-servers, será aberta a aba para configuração. Se quisermos configurar por aqui, podemos ir ao arquivo bruto (raw) para ajustar as configurações dos nossos MCPs. Ou podemos fazer como estávamos fazendo, pelo Antigravity 2.0, que é nosso harness (estrutura de suporte).

Sobre o curso Google Antigravity: construindo software com agentes de IA autônomos

O curso Google Antigravity: construindo software com agentes de IA autônomos possui 99 minutos de vídeos, em um total de 38 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• capitulo