Dê um ‘cérebro especializado’ ao agente: como criar Agent Skills personalizadas para o Antigravity

Na semana passada, um integrante da minha equipe me perguntou pela enésima vez: “Afinal, como funciona o fluxo de autenticação desta API?”

Abri aquela página do Confluence esquecida havia muito tempo e percebi que a última atualização tinha sido feita seis meses antes. A documentação e o código estavam novamente fora de sincronia. Suspirei e comecei a digitar, mais uma vez, a explicação que eu já havia dado incontáveis vezes.

Naquela noite, enquanto experimentava o Antigravity, descobri por acaso o sistema de Skills. Em poucas palavras, ele permite implantar um “cérebro especializado” em um agente de IA, fazendo com que ele se lembre de conhecimentos específicos, execute determinados processos e use ferramentas específicas.

Levei duas horas para criar uma Skill para uma de nossas APIs internas. No dia seguinte, quando uma pessoa nova da equipe fez a mesma pergunta, digitei apenas uma frase no Antigravity: “Consulte o fluxo de autenticação do nosso serviço de usuários.”

O agente chamou minha Skill e, trinta segundos depois, apresentou uma explicação correta, acompanhada de exemplos de código. A pessoa entendeu e seguiu em frente por conta própria.

Foi nesse momento que percebi: o sistema de Skills não serve apenas para criar extensões; ele está reformulando a maneira como as equipes colaboram.

Este artigo explica como criar Skills personalizadas para o Antigravity. Vamos dos conceitos básicos a casos práticos, incluindo a integração com APIs externas e a conexão com bases de conhecimento privadas.

O que são Antigravity Skills

Primeiro, vamos esclarecer o conceito.

O sistema de Skills do Antigravity é um formato de extensão leve e aberto. Você pode entendê-lo como um conjunto de “aplicativos” instalados em um agente de IA: cada Skill define capacidades específicas e torna o agente mais especializado em determinados cenários.

Segundo a documentação do Google Codelabs, Skills são pacotes organizados em diretórios, com um formato padronizado que permite ao agente interpretá-los e executá-los de maneira confiável. Uma Skill típica contém:

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

• skill.yaml: define os metadados, a descrição das capacidades e os cenários de uso da Skill
• README.md: explica em detalhes as funções da Skill e como usá-la
• scripts/: contém os scripts efetivamente executados (Python, Bash etc.)
• templates/: armazena modelos de prompt ou de saída

As Skills podem ser definidas em dois escopos:

• Escopo global (~/.gemini/antigravity/skills/): disponível em diferentes projetos, para tarefas como “formatar JSON” ou “fazer uma revisão genérica de código”
• Escopo do projeto (.agent/skills/): disponível apenas no projeto atual, para itens como “os padrões de API da nossa equipe” ou “modelos de código de uma área específica do negócio”

Essa separação é bastante prática: o que for genérico fica no escopo global, e o que estiver ligado ao negócio fica no projeto.

Crie sua primeira Skill

Agora é hora de colocar a mão na massa.

Vamos começar com um exemplo simples: uma Skill que formata automaticamente mensagens de commit do Git.

Etapa 1: crie a estrutura de diretórios

mkdir -p ~/.gemini/antigravity/skills/git-commit-formatter

Etapa 2: escreva o skill.yaml

name: git-commit-formatter
description: Format Git commit messages following Conventional Commits spec
version: 1.0.0
author: your-name
triggers:
  - commit
  - git message
  - format commit
actions:
  - name: format_commit
    description: Format a raw commit message to Conventional Commits format
    input:
      raw_message: string
      type: enum[feat, fix, docs, style, refactor, test, chore]
    output:
      formatted_message: string

Esse YAML define as informações básicas da Skill, as palavras-chave que a acionam e os formatos de entrada e saída.

Etapa 3: escreva o script de execução

Crie o arquivo scripts/format_commit.py dentro do diretório:

#!/usr/bin/env python3
import sys
import re

def format_commit(raw_message, commit_type):
    # Analisa a mensagem original
    scope_match = re.search(r'\(([^)]+)\)', raw_message)
    scope = f"({scope_match.group(1)})" if scope_match else ""

    # Extrai a descrição
    desc = re.sub(r'\([^)]+\):?\s*', '', raw_message).strip()

    # Formata a mensagem
    formatted = f"{commit_type}{scope}: {desc}"
    return formatted

if __name__ == "__main__":
    raw = sys.argv[1]
    ctype = sys.argv[2]
    print(format_commit(raw, ctype))

Etapa 4: faça um teste

Reinicie o Antigravity e tente inserir:

“Use o git-commit-formatter para formatar este commit: corrigi o bug de login do usuário”

Se tudo estiver funcionando, o agente chamará sua Skill e produzirá algo como: fix(auth): corrigi o bug de login do usuário.

Simples, não é? Esse é o esqueleto básico de uma Skill.

Integração com APIs externas: GitHub + Jira na prática

Uma Skill que funciona apenas localmente ainda é limitada. Ela se torna realmente útil quando consegue se conectar a sistemas externos.

Vamos criar uma Skill capaz de automatizar o trabalho com tickets do Jira.

Cenário: todos os dias, a equipe gasta muito tempo atualizando status e registrando horas no Jira. Vamos deixar o agente cuidar dessas tarefas repetitivas.

Etapa 1: prepare a autenticação da API

Você precisará do token de API e do domínio do Jira. A recomendação é armazenar informações sensíveis em variáveis de ambiente:

export JIRA_API_TOKEN="your-token"
export JIRA_DOMAIN="your-domain.atlassian.net"
export JIRA_EMAIL="[email protected]"

Etapa 2: escreva a configuração da Skill

name: jira-assistant
description: Automate Jira workflows - search issues, update status, add worklogs
triggers:
  - jira
  - ticket
  - issue
  - worklog
actions:
  - name: search_issues
    description: Search Jira issues by JQL query
  - name: add_worklog
    description: Add time spent to an issue
  - name: transition_issue
    description: Move issue to a different status

Etapa 3: escreva o script principal

#!/usr/bin/env python3
import os
import requests
from base64 import b64encode

class JiraClient:
    def __init__(self):
        self.domain = os.getenv('JIRA_DOMAIN')
        self.email = os.getenv('JIRA_EMAIL')
        self.token = os.getenv('JIRA_API_TOKEN')
        self.auth = self._get_auth()

    def _get_auth(self):
        credentials = f"{self.email}:{self.token}"
        return b64encode(credentials.encode()).decode()

    def search(self, jql):
        url = f"https://{self.domain}/rest/api/2/search"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        response = requests.get(url, headers=headers, params={"jql": jql})
        return response.json()

    def add_worklog(self, issue_key, time_spent, comment):
        url = f"https://{self.domain}/rest/api/2/issue/{issue_key}/worklog"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        data = {
            "timeSpent": time_spent,
            "comment": comment
        }
        return requests.post(url, headers=headers, json=data)

# Ponto de entrada da CLI
if __name__ == "__main__":
    import sys
    client = JiraClient()

    if sys.argv[1] == "search":
        result = client.search(sys.argv[2])
        for issue in result.get('issues', []):
            print(f"{issue['key']}: {issue['fields']['summary']}")

    elif sys.argv[1] == "worklog":
        client.add_worklog(sys.argv[2], sys.argv[3], sys.argv[4])
        print(f"Worklog added to {sys.argv[2]}")

Etapa 4: use a Skill

Agora você pode dizer ao Antigravity:

“Consulte todos os tickets do Jira que estão comigo e têm o status In Progress.”

“Registre duas horas de trabalho no PROJ-123 com o comentário ‘concluí a refatoração do módulo de usuários’.”

“Mude o status do PROJ-456 para Done.”

O agente chamará automaticamente a API do Jira, sem que você precise abrir aquela interface lenta.

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

A integração com o GitHub funciona de maneira semelhante: basta usar a biblioteca PyGithub ou chamar diretamente a API do GitHub com requests. Você pode criar uma Skill para abrir PRs automaticamente, verificar o status da CI ou até fazer revisões de código.

Conecte uma base de conhecimento privada: NotebookLM + Antigravity

Esta é a parte que mais me empolga.

Há um caso bastante interessante publicado no XDA Developers: o autor enviou a documentação do projeto ao NotebookLM, pediu que ele gerasse especificações técnicas e depois converteu essas especificações em uma Antigravity Skill. Com isso, o agente passou a escrever código diretamente com base na documentação do projeto.

Como funciona:

O NotebookLM permite exportar conteúdo e transformar conversas em documentos estruturados. Podemos:

1. Criar uma base de conhecimento do projeto no NotebookLM (documentos de design, especificações de API e decisões de arquitetura)
2. Usar o recurso de perguntas e respostas do NotebookLM para preparar um “resumo de conhecimento”
3. Converter esses resumos em arquivos context ou templates da Skill

Outra possibilidade mais direta é conectar o NotebookLM ao Antigravity por meio do MCP (Model Context Protocol).

O projeto de código aberto notebooklm-antigravity-skill, disponível no GitHub, implementa essa integração por meio da CLI nlm:

name: notebooklm-knowledge
description: Query project knowledge from NotebookLM
triggers:
  - consultar documentação
  - verificar padrões
  - conhecimento do projeto
actions:
  - name: query_knowledge
    description: Query NotebookLM for project-specific knowledge

Ao chamar a API do NotebookLM pelo script, o agente consegue consultar sua base de conhecimento privada em tempo real.

Imagine este cenário:

Pessoa nova na equipe: “Qual é o nosso padrão para tratamento de erros?”
Você, no Antigravity: “Consulte o padrão de tratamento de erros no NotebookLM.”
Agente: “Segundo a documentação do projeto, o padrão de tratamento de erros é o seguinte: 1. usar classes de exceção personalizadas… 2. incluir o traceback nos logs… 3. internacionalizar os erros exibidos ao usuário…”

A documentação deixa de ficar esquecida e passa a ser o “cérebro especializado” do agente.

Técnica avançada: combine Rules e Skills

Além das Skills, o Antigravity também tem um sistema de “Rules”. A combinação dos dois é ainda mais poderosa.

Rules são restrições de comportamento no nível global ou do projeto, por exemplo:

# .agent/rules/code-review.md

Ao fazer uma revisão de código:
1. Verifique se há cobertura suficiente de testes unitários
2. Confirme que não existem informações sensíveis gravadas diretamente no código
3. Valide se o tratamento de erros está completo
4. Verifique se o código segue os padrões de TypeScript da equipe

A Rule define “quando e como agir”, enquanto a Skill define “como executar na prática”.

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Desenvolvedores da Atlassian compartilharam em seu blog um caso real: eles definiram uma regra app-deployment para o Antigravity e a combinaram com Jira Skills para automatizar o processo de implantação.

Quando o agente detecta que o código foi mesclado à branch main:

1. A Rule é acionada: “execute as verificações anteriores à implantação”
2. A Skill verifica o status do ticket relacionado no Jira
3. A Skill executa a suíte de testes
4. Se tudo passar, a Skill atualiza o status no Jira e registra o log da implantação

Com essa combinação, um processo que antes exigia mais de dez etapas manuais agora pode ser acionado com uma única frase.

Conclusão

Depois de tudo isso, a ideia central cabe em uma frase: Skills transformam o Antigravity de uma “ferramenta genérica” em um “assistente especializado”.

Uma IA genérica sabe escrever código, mas não conhece o seu negócio. Com Skills, você pode incorporar ao agente o conhecimento da empresa, os padrões da equipe e as ferramentas internas, fazendo com que ele realmente se torne parte da equipe.

Comecei criando meu primeiro formatador de commits do Git. Hoje, nossa equipe já acumulou mais de vinte Skills internas. Consulta à documentação de APIs, verificação de padrões de código, processamento de tickets do Jira e até onboarding de novos integrantes: todas essas tarefas repetitivas estão sendo transferidas aos poucos para o agente.

Não é uma questão de ficarmos preguiçosos, mas de podermos concentrar energia em trabalhos mais valiosos. Projetar arquiteturas, resolver problemas difíceis e criar novos produtos: são essas as tarefas que pedem intervenção humana. Consultas repetitivas de conhecimento e operações rotineiras? Deixe o agente cuidar delas.

Se você também quiser experimentar, recomendo começar por um pequeno incômodo. Identifique aquela pergunta que a equipe já respondeu inúmeras vezes ou aquele processo repetido dez vezes por dia e crie uma Skill para resolvê-lo.

Você perceberá que o agente não é apenas uma ferramenta: ele é uma extensão da equipe.

E as Skills são a chave que lhe dá capacidades especializadas.