Criação de habilidades do Google Antigravity

1. Introdução

O Google Antigravity é uma plataforma de desenvolvimento agêntica criada para ajudar você a desenvolver nessa era de agentes. O Antigravity é o centro de comando central dos seus agentes de IA, oferecendo uma plataforma unificada para iniciar, monitorar e orquestrar as atividades deles.

Neste codelab, vamos primeiro aprender sobre as habilidades de agentes, um formato aberto e leve para estender os recursos dos agentes de IA com conhecimento e fluxos de trabalho especializados. Você vai aprender o que são as habilidades do agente, os benefícios delas e como são construídas. Em seguida, você vai criar várias habilidades de agente, desde um formatador do Git, um gerador de modelos, uma estrutura de código de ferramentas e muito mais, tudo utilizável no Antigravity.

Pré-requisitos:

• O Antigravity está instalado e configurado.
• Conhecimentos básicos sobre o Google Antigravity. Recomendamos que você conclua o codelab: Introdução ao Google Antigravity.

2. Por que usar o Skills

Os agentes de IA modernos evoluíram de simples ouvintes para solucionadores de problemas complexos que se integram a sistemas de arquivos locais e ferramentas externas (via servidores MCP). No entanto, carregar um agente indiscriminadamente com bases de código inteiras e centenas de ferramentas leva à saturação de contexto e ao "inchaço de ferramentas". Mesmo com grandes janelas de contexto, despejar 40 a 50 mil tokens de ferramentas não usadas na memória ativa causa alta latência, desperdício financeiro e "deterioração do contexto", em que o modelo fica confuso com dados irrelevantes.

A solução: habilidades do agente

Para resolver isso, a Anthropic introduziu as Habilidades do agente, mudando a arquitetura do carregamento de contexto monolítico para a Divulgação progressiva. Em vez de forçar o modelo a "memorizar" todos os fluxos de trabalho específicos (como migrações de banco de dados ou auditorias de segurança) no início de uma sessão, essas funcionalidades são agrupadas em unidades modulares e detectáveis.

Como funciona

Inicialmente, o modelo é exposto apenas a um "menu" leve de metadados. Ele carrega o conhecimento processual pesado (instruções e scripts) apenas quando a intenção do usuário corresponde especificamente a uma habilidade. Isso garante que um desenvolvedor que pede para refatorar o middleware de autenticação receba o contexto de segurança sem carregar pipelines CSS não relacionados, mantendo o contexto simples, rápido e econômico.

3. Habilidades do agente e antigravidade

No ecossistema da Antigravity, as habilidades atuam como módulos de treinamento especializados que preenchem a lacuna entre os modelos generalistas e seu contexto específico. Eles permitem que o agente "equipe" um conjunto definido de instruções e protocolos, como padrões de migração de banco de dados ou verificações de segurança, somente quando uma tarefa relevante é solicitada. Ao carregar dinamicamente esses protocolos de execução, as Skills transformam a IA de um programador genérico em um especialista que segue rigorosamente as práticas recomendadas e os padrões de segurança codificados de uma organização.

O que é uma habilidade no Antigravity?

No contexto do Google Antigravity, uma habilidade é um pacote baseado em diretório que contém um arquivo de definição (SKILL.md) e recursos de suporte opcionais (scripts, referências, modelos).

É um mecanismo para extensão de recursos sob demanda.

• Sob demanda: ao contrário de um comando do sistema (que é sempre carregado), uma skill só é carregada no contexto do agente quando ele determina que é relevante para a solicitação atual do usuário. Isso otimiza a janela de contexto e evita que o agente se distraia com instruções irrelevantes. Em projetos grandes com dezenas de ferramentas, esse carregamento seletivo é crucial para o desempenho e a precisão do raciocínio.
• Extensão de capacidade: as skills podem fazer mais do que apenas instruir, elas podem executar. Ao agrupar scripts Python ou Bash, uma habilidade pode dar ao agente a capacidade de realizar ações complexas e de várias etapas na máquina local ou em redes externas sem que o usuário precise executar comandos manualmente. Isso transforma o agente de um gerador de texto em um usuário de ferramentas.

Habilidades x ecossistema (ferramentas, regras e fluxos de trabalho)

Enquanto o Protocolo de Contexto de Modelo (MCP) funciona como as "mãos" do agente, fornecendo conexões persistentes e robustas a sistemas externos como GitHub ou PostgreSQL, as habilidades atuam como o "cérebro" que as direciona.

O MCP processa a infraestrutura com estado, enquanto as habilidades são definições de tarefas leves e efêmeras que empacotam a metodologia para usar essas ferramentas. Essa abordagem sem servidor permite que os agentes executem tarefas ad hoc (como gerar changelogs ou migrações) sem a sobrecarga operacional de processos persistentes, carregando o contexto apenas quando a tarefa está ativa e liberando-o imediatamente depois.

As habilidades são acionadas pelo agente: o modelo detecta automaticamente a intenção do usuário e equipa dinamicamente a expertise específica necessária. Essa arquitetura permite uma capacidade de composição eficiente. Por exemplo, uma regra global pode exigir o uso de uma habilidade de "migração segura" durante mudanças no banco de dados, ou um único fluxo de trabalho pode orquestrar várias habilidades para criar um pipeline de implantação robusto.

4. Como criar habilidades

A criação de uma Skill no Antigravity segue uma estrutura de diretórios e um formato de arquivo específicos. Essa padronização garante que as habilidades sejam portáteis e que o agente possa analisá-las e executá-las de maneira confiável. O design é intencionalmente simples, contando com formatos amplamente compreendidos, como Markdown e YAML, reduzindo a barreira de entrada para desenvolvedores que querem ampliar os recursos do IDE.

Estrutura de diretórios

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

my-skill/
├── SKILL.md # The definition file
├── scripts/ # [Optional] Python, Bash, or Node scripts
     ├── run.py
     └── util.sh
├── references/ # [Optional] Documentation or templates
     └── api-docs.md
└── assets/ # [Optional] Static assets (images, logos)

Essa estrutura separa as questões de maneira eficaz. A lógica (scripts) é separada da instrução (SKILL.md) e do conhecimento (references), espelhando as práticas padrão de engenharia de software.

O arquivo de definição SKILL.md

O arquivo SKILL.md é o cérebro da skill. Ele informa ao agente o que é a habilidade, quando e como usá-la.

Ele consiste em duas partes:

• YAML Frontmatter
• Corpo em Markdown.

YAML Frontmatter

Essa é a camada de metadados. É a única parte da habilidade indexada pelo roteador de alto nível do agente. Quando um usuário envia um comando, o agente faz uma correspondência semântica entre o comando e os campos de descrição de todas as habilidades disponíveis.

---
name: database-inspector
description: Use this skill when the user asks to query the database, check table schemas, or inspect user data in the local PostgreSQL instance.
---

Campos-chave:

• name: não é obrigatório. Precisa ser exclusivo no escopo. Minúsculas, hífens permitidos (por exemplo, postgres-query, pr-reviewer). Se não for fornecido, o padrão será o nome do diretório.
• description: obrigatório e o campo mais importante. Ela funciona como a "frase de ativação". Ela precisa ser descritiva o suficiente para que o LLM reconheça a relevância semântica. Uma descrição vaga como "Ferramentas de banco de dados" não é suficiente. Uma descrição precisa como "Executa consultas SQL somente leitura no banco de dados PostgreSQL local para recuperar dados de usuários ou transações. Use isso para depurar estados de dados" garante que a habilidade seja captada corretamente.

O corpo do Markdown

O corpo contém as instruções. Isso é a "engenharia de comando" persistida em um arquivo. Quando a habilidade é ativada, esse conteúdo é injetado na janela de contexto do agente.

O corpo precisa incluir:

1. Objetivo: uma declaração clara do que a habilidade realiza.
2. Instruções: lógica detalhada.
3. Exemplos: exemplos de poucas imagens de entradas e saídas para orientar o desempenho do modelo.
4. Restrições: regras de "não" (por exemplo, "Não execute consultas DELETE").

Exemplo de corpo de SKILL.md:

Database Inspector

Goal
To safely query the local database and provide insights on the current data state.

Instructions
- Analyze the user's natural language request to understand the data need.
- Formulate a valid SQL query.
 - CRITICAL: Only SELECT statements are allowed.
- Use the script scripts/query_runner.py to execute the SQL.
 - Command: python scripts/query_runner.py "SELECT * FROM..."
- Present the results in a Markdown table.

Constraints
- Never output raw user passwords or API keys.
- If the query returns > 50 rows, summarize the data instead of listing it all.

Integração de script

Um dos recursos mais avançados do Skills é a capacidade de delegar a execução a scripts. Isso permite que o agente execute ações difíceis ou impossíveis para um LLM fazer diretamente (como execução binária, cálculo matemático complexo ou interação com sistemas legados).

Os scripts são colocados no subdiretório scripts/. O SKILL.md faz referência a eles por caminho relativo.

5. Habilidades de criação

O objetivo desta seção é criar habilidades que se integram ao Antigravity e mostram progressivamente vários recursos, como recursos/scripts etc.

Faça o download das habilidades no repositório do GitHub: https://github.com/rominirani/antigravity-skills.

Antes de entendermos como cada uma dessas habilidades foi criada, vamos ver como configurá-las e disponibilizá-las no pacote de produtos Antigravity. As pastas abaixo são válidas no momento da publicação deste laboratório.

Como usar o Antigravity ou a CLI do Antigravity

As habilidades podem ser definidas em dois escopos, permitindo habilidades específicas do projeto e do usuário, ou seja, globais:

• Escopo global (~/.gemini/config/skills/): disponível em todos os produtos do Antigravity (Antigravity, IDE do Antigravity, CLI do Antigravity) e projetos. Essas habilidades estão disponíveis em todos os projetos na máquina do usuário. Isso é adequado para utilitários gerais, como "Formatar JSON", "Gerar UUIDs", "Revisar estilo de código" ou integração com ferramentas de produtividade pessoal.
• Escopo do projeto/espaço de trabalho (<project-root>/.agents/skills/): isso disponibilizaria a habilidade apenas em um projeto específico. Isso é ideal para scripts específicos do projeto, como implantação em um ambiente específico, gerenciamento de banco de dados para esse app ou geração de código boilerplate para uma estrutura proprietária.

Instalar as Skills no Antigravity ou na CLI do Antigravity

Para este tutorial, basta seguir estas etapas (você também pode fazer do seu jeito):

Etapa 1: faça um git clone de https://github.com/rominirani/antigravity-skills

Etapa 2: dependendo se você está usando o Antigravity ou a CLI do Antigravity, navegue até a pasta antigravity-skills/skills_tutorial.

Etapa 3: você vai encontrar um conjunto de habilidades, agrupadas nas respectivas pastas. Copie as quatro pastas a seguir:

• git-commit-formatter
• license-header-adder
• database-schema-validator
• json-to-pydantic

na pasta de habilidades segmentadas do produto (escopo do projeto ou global).

Etapa 4:se você estiver usando o Antigravity ou a CLI do Antigravity , copie para <project-root>/.agents/skills/ (escopo do projeto).

Se você tiver iniciado o Antigravidade, faça uma pergunta simples como "Quais habilidades estão disponíveis?" e ele vai responder com a mesma pergunta. Você pode conferir as quatro habilidades listadas ali. Você também pode ter outras habilidades se as tiver instalado no seu ambiente.

Da mesma forma, se você estiver usando a CLI do Antigravity, poderá usar o seguinte comando /skills, que vai listar as quatro habilidades. Veja a seguir um exemplo do objeto :

Agora que já sabemos como configurar as habilidades, vamos analisar cada uma delas e entender como foram criadas. Você também pode usar esses modelos para criar suas próprias skills.

Nível 1 : o roteador básico ( git-commit-formatter)

Vamos considerar isso como o "Hello World" das habilidades.

Os desenvolvedores costumam escrever mensagens de commit preguiçosas, por exemplo, "wip", "fix bug", "updates". Aplicar "Conventional Commits" manualmente é tedioso e muitas vezes esquecido. Vamos implementar uma habilidade que aplique a especificação de commits convencionais. Ao instruir o agente sobre as regras, permitimos que ele atue como fiscalizador.

git-commit-formatter/
└── SKILL.md  (Instructions only)

O arquivo SKILL.md é mostrado abaixo:

---
name: git-commit-formatter
description: Formats git commit messages according to Conventional Commits specification. Use this when the user asks to commit changes or write a commit message.
---

Git Commit Formatter Skill

When writing a git commit message, you MUST follow the Conventional Commits specification.

Format
`<type>[optional scope]: <description>`

Allowed Types
- **feat**: A new feature
- **fix**: A bug fix
- **docs**: Documentation only changes
- **style**: Changes that do not affect the meaning of the code (white-space, formatting, etc)
- **refactor**: A code change that neither fixes a bug nor adds a feature
- **perf**: A code change that improves performance
- **test**: Adding missing tests or correcting existing tests
- **chore**: Changes to the build process or auxiliary tools and libraries such as documentation generation

Instructions
1. Analyze the changes to determine the primary `type`.
2. Identify the `scope` if applicable (e.g., specific component or file).
3. Write a concise `description` in an imperative mood (e.g., "add feature" not "added feature").
4. If there are breaking changes, add a footer starting with `BREAKING CHANGE:`.

Example
`feat(auth): implement login with google`

Como executar este exemplo no Antigravity

As etapas abaixo pressupõem que você tenha o Git disponível na máquina local e configurado corretamente.

Supondo que você tenha iniciado o Antigravity ou a CLI do Antigravity, siga estas etapas:

Etapa 1: configurar um repositório Git de teste

Peça ao agente para configurar um diretório limpo e isolado para testar operações do Git.

Seu comando:

Create a folder named git_test in the workspace, initialize a git repository inside it, and create an initial file auth.py with def login(): pass. Stage this file and make an initial commit.

O agente vai criar o diretório, inicializar o repositório, preparar o arquivo e fazer o commit com uma mensagem como "initial commit".

Etapa 2: fazer uma mudança no código

Diga ao agente para modificar o código para que haja uma mudança a ser confirmada.

Seu comando:

In the git_test folder, modify auth.py to add Google Login functionality.

O agente vai editar o arquivo para adicionar um novo recurso, preparando-o para a fase de commit.

Etapa 3: preparar e confirmar as mudanças

Ative a habilidade git-commit-formatter pedindo ao agente para preparar as mudanças e criar um commit.

Seu comando:

Stage the changes in the git_test folder and commit them. Make sure to format the commit message using the Conventional Commits skill.

O agente vai executar git add auth.py, analisar a diff para determinar que um novo recurso foi adicionado ao módulo auth e formular uma mensagem de commit convencional como feat(auth): implement google login antes de executar git commit.

Etapa 4: verificar o registro do Git

Peça ao agente para recuperar o histórico do Git e confirmar se o commit formatado foi gravado.

Seu comando:

Show me the git log in the git_test folder.

O agente vai executar git log -n 5 e retornar a saída mostrando a mensagem de commit formatada.

Nível 2: utilização de recursos (license-header-adder)

Esse é o padrão "Referência".

Cada arquivo de origem em um projeto corporativo pode precisar de um cabeçalho de licença Apache 2.0 específico de 20 linhas. Colocar esse texto estático diretamente no comando (ou SKILL.md) é um desperdício. Ele consome tokens sempre que a habilidade é indexada, e o modelo pode "alucinar" erros de digitação em textos jurídicos. É uma boa prática descarregar o texto estático em um arquivo de texto simples em uma pasta resources/. A habilidade instrui o agente a ler esse arquivo apenas quando necessário.

Os arquivos estão na pasta license-header-adder do diretório skills.

license-header-adder/
├── SKILL.md
└── resources/
   └── HEADER_TEMPLATE.txt  (The heavy text)

O arquivo SKILL.md é mostrado abaixo:

---
name: license-header-adder
description: Adds the standard open-source license header to new source files. Use involves creating new code files that require copyright attribution.
---

# License Header Adder Skill

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

## Instructions

1. **Read the Template**:
  First, read the content of the header template file located at `resources/HEADER_TEMPLATE.txt`.

2. **Prepend to File**:
  When creating a new file (e.g., `.py`, `.java`, `.js`, `.ts`, `.go`), prepend the `target_file` content with the template content.

3. **Modify Comment Syntax**:
  - For C-style languages (Java, JS, TS, C++), keep the `/* ... */` block as is.
  - For Python, Shell, or YAML, convert the block to use `#` comments.
  - For HTML/XML, use `<!-- ... -->`.

Como executar este exemplo no Antigravity

Supondo que você tenha iniciado o Antigravity ou a CLI do Antigravity, siga estas etapas:

Etapa 1: criar o arquivo Python com o exemplo de código

Seu comando:

Create a new file my_script.py with the following python code:

def hello():
   print("Hello, World!")

O que aconteceu (explicação): o agente invocou uma ferramenta de gravação de arquivos (write_to_file) para criar um arquivo chamado my_script.py diretamente no diretório do espaço de trabalho ativo e gravou a função básica do Python nele. Além disso, o comando ativou a habilidade license-header-adder. O agente localizou e leu o arquivo de modelo de licença (HEADER_TEMPLATE.txt), modificou o estilo de comentário de comentários em bloco no estilo C (/* ... */) para comentários no estilo Python (#) e o adicionou ao início do arquivo usando a ferramenta replace_file_content.

Etapa 2: verificar o conteúdo do arquivo

Confira o arquivo my_script.py. Ele vai conter o cabeçalho da licença na parte de cima.

Nível 3: aprendizado por exemplo (json-to-pydantic)

O padrão "Few-Shot".

Converter dados soltos (como uma resposta da API JSON) em código estrito (como modelos Pydantic) envolve dezenas de decisões. Como devemos nomear as classes? Devemos usar Optional? snake_case ou camelCase? Escrever essas 50 regras em inglês é tedioso e propenso a erros.

Os LLMs são mecanismos de correspondência de padrões.

Criar sua habilidade com um exemplo de ouro (Input -> Output) geralmente é mais eficaz do que instruções detalhadas.

Acesse a pasta json-to-pydantic/ que contém os arquivos de habilidade, conforme mostrado abaixo:

json-to-pydantic/
├── SKILL.md
└── examples/
   ├── input_data.json   (The Before State)
   └── output_model.py   (The After State)

O arquivo SKILL.md é mostrado abaixo:

---
name: json-to-pydantic
description: Converts JSON data snippets into Python Pydantic data models.
---

# JSON to Pydantic Skill

This skill helps convert raw JSON data or API responses into structured, strongly-typed Python classes using Pydantic.

Instructions

1. **Analyze the Input**: Look at the JSON object provided by the user.
2. **Infer Types**:
  - `string` -> `str`
  - `number` -> `int` or `float`
  - `boolean` -> `bool`
  - `array` -> `List[Type]`
  - `null` -> `Optional[Type]`
  - Nested Objects -> Create a separate sub-class.
 
3. **Follow the Example**:
  Review `examples/` to see how to structure the output code. notice how nested dictionaries like `preferences` are extracted into their own class.
 
  - Input: `examples/input_data.json`
  - Output: `examples/output_model.py`

Style Guidelines
- Use `PascalCase` for class names.
- Use type hints (`List`, `Optional`) from `typing` module.
- If a field can be missing or null, default it to `None`.

Na pasta /examples, há o arquivo JSON e o arquivo de saída, ou seja, o arquivo Python. Ambos são mostrados abaixo:

input_data.json

{
   "user_id": 12345,
   "username": "jdoe_88",
   "is_active": true,
   "preferences": {
       "theme": "dark",
       "notifications": [
           "email",
           "push"
       ]
   },
   "last_login": "2024-03-15T10:30:00Z",
   "meta_tags": null
}

output_model.py

from pydantic import BaseModel, Field
from typing import List, Optional

class Preferences(BaseModel):
   theme: str
   notifications: List[str]

class User(BaseModel):
   user_id: int
   username: str
   is_active: bool
   preferences: Preferences
   last_login: Optional[str] = None
   meta_tags: Optional[List[str]] = None

Como executar este exemplo no Antigravity

Supondo que você tenha iniciado o Antigravity ou a CLI do Antigravity, siga estas etapas:

Etapa 1: criar o arquivo JSON com dados de amostra

Peça ao agente para criar um novo arquivo product.json que contenha o payload JSON bruto.

Seu comando:

Create a new file product.json with the following JSON:

{
 "product": "Widget",
 "cost": 10.99,
 "stock": null
}

Etapa 2: converter o JSON em um modelo Pydantic

Acione a habilidade json-to-pydantic para converter os dados JSON em uma classe Pydantic estruturada.

Seu comando:

Convert the JSON in product.json to a Pydantic model and save it to product_model.py.

Etapa 3: verificar a saída

Confira o arquivo product_model.py. Ele vai conter o modelo Pydantic concluído.

Nível 4: lógica procedural (database-schema-validator)

Esse é o padrão "Uso de ferramentas".

Se você perguntar a um LLM "Este esquema é seguro?", ele pode dizer que está tudo bem, mesmo que uma chave primária crítica esteja faltando, simplesmente porque o SQL parece correto.

Vamos delegar essa verificação a um script determinístico. Nossa habilidade database-schema-validator vai direcionar o agente para executar um script Python que escrevemos. O script fornece uma verdade binária (verdadeiro/falso).

database-schema-validator/
├── SKILL.md
└── scripts/
   └── validate_schema.py  (The Validator)

O arquivo SKILL.md é mostrado abaixo:

---
name: database-schema-validator
description: Validates SQL schema files for compliance with internal safety and naming policies.
---

# Database Schema Validator Skill

This skill ensures that all SQL files provided by the user comply with our strict database standards.

Policies Enforced
1. **Safety**: No `DROP TABLE` statements.
2. **Naming**: All tables must use `snake_case`.
3. **Structure**: Every table must have an `id` column as PRIMARY KEY.

Instructions

1. **Do not read the file manually** to check for errors. The rules are complex and easily missed by eye.
2. **Run the Validation Script**:
  Use the `run_command` tool to execute the python script provided in the `scripts/` folder against the user's file.
 
  `python scripts/validate_schema.py <path_to_user_file>`

3. **Interpret Output**:
  - If the script returns **exit code 0**: Tell the user the schema looks good.
  - If the script returns **exit code 1**: Report the specific error messages printed by the script to the user and suggest fixes.

O arquivo validate_schema.py é mostrado abaixo:

import sys
import re

def validate_schema(filename):
   """
   Validates a SQL schema file against internal policy:
   1. Table names must be snake_case.
   2. Every table must have a primary key named 'id'.
   3. No 'DROP TABLE' statements allowed (safety).
   """
   try:
       with open(filename, 'r') as f:
           content = f.read()
          
       lines = content.split('\n')
       errors = []
      
       # Check 1: No DROP TABLE
       if re.search(r'DROP TABLE', content, re.IGNORECASE):
           errors.append("ERROR: 'DROP TABLE' statements are forbidden.")
          
       # Check 2 & 3: CREATE TABLE checks
       table_defs = re.finditer(r'CREATE TABLE\s+(?P<name>\w+)\s*\((?P<body>.*?)\);', content, re.DOTALL | re.IGNORECASE)
      
       for match in table_defs:
           table_name = match.group('name')
           body = match.group('body')
          
           # Snake case check
           if not re.match(r'^[a-z][a-z0-9_]*$', table_name):
               errors.append(f"ERROR: Table '{table_name}' must be snake_case.")
              
           # Primary key check
           if not re.search(r'\bid\b.*PRIMARY KEY', body, re.IGNORECASE):
               errors.append(f"ERROR: Table '{table_name}' is missing a primary key named 'id'.")

       if errors:
           for err in errors:
               print(err)
           sys.exit(1)
       else:
           print("Schema validation passed.")
           sys.exit(0)
          
   except FileNotFoundError:
       print(f"Error: File '{filename}' not found.")
       sys.exit(1)

if __name__ == "__main__":
   if len(sys.argv) != 2:
       print("Usage: python validate_schema.py <schema_file>")
       sys.exit(1)
      
   validate_schema(sys.argv[1])

Como executar este exemplo no Antigravity

Supondo que você tenha iniciado o Antigravity ou a CLI do Antigravity, siga estas etapas:

Etapa 1: criar o arquivo JSON com dados de amostra

Peça ao agente para criar um novo arquivo bad_schema.sql com várias violações de política.

Seu comando:

Create a new file bad_schema.sql with the following SQL:

DROP TABLE IF EXISTS legacy_users;

CREATE TABLE userProfile (
    id INT PRIMARY KEY,
    bio TEXT
);

CREATE TABLE posts (
    title TEXT,
    content TEXT,
    created_at TIMESTAMP
);

CREATE TABLE comments (
    id INT PRIMARY KEY,
    post_id INT,
    body TEXT
);

O arquivo de esquema acima viola todas as três políticas: ele usa uma instrução DROP TABLE proibida, usa camelCase para o nome da tabela userProfile e esquece a chave primária id na tabela posts.

Etapa 2: validar o esquema SQL

Acione a skill database-schema-validator para executar o script validador do Python no seu arquivo.

Seu comando:

Validate bad_schema.sql using the database-schema-validator skill.

Etapa 3: verificar a saída

O agente vai informar a falha e mostrar os erros específicos encontrados pelo script diretamente no chat. Confira abaixo um exemplo da saída:

Suggested Fixes:

Remove the line DROP TABLE IF EXISTS legacy_users; as dropping tables is forbidden by safety policy.

Rename the table userProfile to use snake_case (e.g., user_profile).

Add a primary key column named id to the posts table definition.

6. O kit de ferramentas para desenvolvedores (habilidades da CLI de agentes)

O padrão "Ação e ciclo de vida".

O desenvolvimento de agentes de IA envolve tarefas repetitivas do ciclo de vida: criação de arquivos de modelo, configuração de ambientes de execução locais, execução de comandos de teste e início de playgrounds interativos.

Em vez de forçar seu assistente de programação a adivinhar estruturas de diretórios ou escrever configurações de agente clichê do zero, as habilidades da CLI Agents agrupam essa experiência do ciclo de vida em habilidades específicas do agente.

As habilidades da CLI (interface de linha de comando) do agente trazem automação simplificada e focada no desenvolvedor diretamente para o terminal, diminuindo a distância entre o código bruto e a execução autônoma. Enquanto o Kit de Desenvolvimento de Agente (ADK) se concentra no framework programático, oferecendo SDKs, APIs e projetos estruturais para criar e orquestrar agentes de IA, as habilidades da CLI do agente fornecem a capacidade operacional. Ele permite que os desenvolvedores façam scaffolding, testem e implantem agentes localmente com loops de feedback rápidos, ignorando completamente a sobrecarga pesada da interface.

Opcionalmente, quando mapeadas para o Google Cloud, as habilidades da CLI do agente atuam como um pipeline direto para a infraestrutura de nível empresarial. Em vez de clicar nos consoles, use comandos da CLI para empacotar instantaneamente fluxos de trabalho de agentes, gerenciar permissões de acesso e implantá-los em ecossistemas do Google Cloud, como o Vertex AI ou o Cloud Run. Isso transforma tarefas complexas de arquitetura de nuvem em comandos de terminal simples e reproduzíveis, facilitando muito a integração de agentes autônomos aos pipelines de implantação de CI/CD atuais.

Como instalar

Verifique se você tem o Python 3.11+, o Node.js e o gerenciador de pacotes uv instalados. Em seguida, execute o comando de configuração no terminal:

uvx google-agents-cli setup

Esse comando instala o binário agents-cli e registra as habilidades especializadas dele para scaffolding e avaliação no ambiente do seu assistente de programação.

Observação: as habilidades serão instaladas na pasta ~/.agents/skills, que fica visível para o Antigravity. Se quiser ver essas habilidades na CLI do Antigravity, mova-as para a pasta ~/.gemini/antigravity-cli/skills (escopo global).

Para verificar se as Skills foram carregadas no Antigravity, basta perguntar quais Skills estão disponíveis. Confira abaixo um exemplo de resposta para as habilidades da CLI do agente que acabamos de instalar.

Tutorial

Depois que o uvx google-agents-cli setup for concluído, você poderá ativar, interagir e testar um agente de IA totalmente na sua máquina local.

Etapa 1: criar e inicializar um novo projeto de agente

Execute o comando de criação para criar um layout padronizado. Depois de criado, instale as dependências do projeto antes de executar qualquer tarefa.

# 1. Create a lightweight prototype project structure
agents-cli create weather-assistant --prototype --yes

# 2. Move into the directory and install required ADK dependencies
cd weather-assistant
agents-cli install

O que acontece nos bastidores: isso cria um espaço de trabalho limpo com app/agent.py (seu código principal), pyproject.toml (metadados do pacote) e agents-cli-manifest.yaml (rastreador de projetos).

Etapa 2: executar uma consulta de teste local

Execute um teste rápido e direto na linha de comando com seu agente. Verifique se você exportou o GEMINI_API_KEY no terminal se não estiver usando o ADC (Application Default Credentials) do Google Cloud. Você pode conseguir uma chave da API Gemini aqui. Depois de ter a chave, exporte-a no terminal com o seguinte comando:

export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"

Execute o seguinte comando no terminal:

agents-cli run "How are you?"

O que acontece nos bastidores: a CLI inicializa o ciclo de vida do Kit de Desenvolvimento de Agente (ADK) totalmente na memória do seu terminal. Ele encaminha o comando com segurança pelas suas credenciais locais e registra a resposta da transmissão ao vivo diretamente na linha de comando.

Etapa 3: iniciar o Interactive Web Playground

Inicie o playground local integrado baseado na Web para interagir visualmente com o agente.

agents-cli playground

O que acontece nos bastidores: a CLI inicia um servidor de interface da Web do ADK, geralmente acessível em http://localhost:8080 ou no fallback http://127.0.0.1:8000, com recarregamento dinâmico. Na interface da Web, selecione app no menu suspenso Selecionar um app na parte de cima e interaja com o agente na interface de conversa à direita do aplicativo da Web.

7. Como instalar habilidades do agente usando npx skills

npx skills é uma ferramenta de linha de comando desenvolvida pela Vercel Labs que funciona como um gerenciador de pacotes para agentes de IA (como Antigravity, Claude Code, GitHub Copilot, Cursor e Cline). É a CLI do ecossistema aberto de habilidades de agente.

Se você quiser fazer o download e instalar o Agent Skills usando o pacote npx skills, observe que ele coloca as Skills na pasta ~/.agents/skills. Embora mencione que ferramentas como o Antigravity vão coletar as habilidades dessa pasta, vale lembrar que, no momento da escrita, o Antigravity coleta as habilidades dessa pasta, mas a CLI do Antigravity não. Como mencionado anteriormente, copie essas habilidades instaladas na pasta ~/.agents/skills para o escopo global ou do projeto das pastas de habilidades na CLI do Antigravity. Por exemplo:

1. Escopo do projeto: localizado em <project-root>/.agent/skills/.
2. Escopo global: localizado em ~/.gemini/antigravity-cli/skills/.

8. Parabéns

Parabéns! Você usou o Google Antigravity para criar, configurar e adicionar recursos personalizados à sua primeira habilidade de agente.

Você também configurou um conjunto de habilidades do agente nos escopos global e do projeto, criando ferramentas personalizadas.

Agora você está pronto para deixar o Antigravity cuidar do trabalho pesado nos seus próprios projetos e escrever código do seu jeito.

Ganhe o selo "Agentes de IA em 5 dias do Kaggle"

Você concluiu este laboratório como parte do Curso intensivo de vibe coding de 5 dias sobre agentes de IA com o Google do Kaggle? Reivindique seu selo de conclusão: ganhe o selo de 5 dias de agentes de IA.

9. Documentos de referência

• Codelab : primeiros passos com o Google Antigravity
• Site oficial : https://antigravity.google/
• Documentação: https://antigravity.google/docs
• Download : https://antigravity.google/download
• Documentação do Antigravity Skills: https://antigravity.google/docs/skills