1. Introdução
A programação por vibe, que usa agentes de IA para escrever código com base em comandos de linguagem natural, muda a função do desenvolvedor de autor para organizador e revisor. Confiamos na preparação do contexto perfeito e nos agentes de IA para fazer tudo por nós, desde a criação dos documentos de especificação até a garantia de que o código atenda a todos os requisitos. O risco: em ciclos de iteração rápidos, o código funcional é aprovado sem uma análise de segurança completa. Os agentes modernos geralmente produzem código seguro por padrão, mas "geralmente" não é "sempre", e as vulnerabilidades acumuladas passam pela revisão manual.
Este codelab aborda esses problemas ensinando duas abordagens para usar o Antigravity como revisor: de forma interativa durante o desenvolvimento com a CLI (você revisa, corrige e envia uma solicitação de pull) e de forma automática na integração contínua com o SDK (o agente revisa todas as solicitações de pull e publica os resultados como um comentário).
O que você vai explorar
Você programou um app de CRM de leads com vibração. Um agente de IA criou a pilha completa para você: back-end do Express, banco de dados SQLite e front-end do React. Ele funciona. Em seguida, você pediu ao agente para adicionar dois novos recursos: uma função de pesquisa de leads e importação/exportação em massa com estatísticas de administrador. O agente entregou os dois rapidamente. O código é executado, os recursos funcionam e os PRs estão prontos.
Mas aqui está o problema: você não escreveu esse código. Você aprovou. Como você sabe que o endpoint de pesquisa não está vulnerável a injeção de SQL? Como você sabe que a rota de administrador não tem uma senha codificada? Você não precisa fazer isso, e ler cada linha de código gerado por IA anula a vantagem de velocidade que fez você usar o vibe-code em primeiro lugar.
Este codelab oferece duas maneiras de resolver isso:
- Caso 1: revisão interativa: confira uma ramificação de recurso com vulnerabilidades, use a CLI do Antigravity aprimorada com habilidades de agente para revisar a diferença, corrija os problemas e crie uma solicitação de pull limpa.
- Caso 2: análise automática: configure uma ação do GitHub com tecnologia do SDK do Antigravity que revisa automaticamente as solicitações de envio, posta descobertas estruturadas como comentários e responde quando os desenvolvedores fazem perguntas de acompanhamento sobre a revisão.
O que você vai aprender
- Como a programação de vibe pode criar riscos de segurança e por que a análise automática detecta o que a revisão manual não detecta
- Como instalar e usar habilidades de agente mantidas pela comunidade para dar à CLI do Antigravity experiência em segurança e revisão de código
- Como usar a CLI de forma interativa para analisar um diff de ramificação de recurso, corrigir vulnerabilidades e criar um PR limpo
- Como usar o SDK do Antigravity para criar um agente de revisão de código somente leitura com políticas de segurança declarativas e hooks de ciclo de vida
- Como implantar o agente de revisão como uma ação do GitHub que revisa PRs e posta o resultado como um comentário de PR
Pré-requisitos
- Uma conta do Google Cloud
- Uma conta no GitHub
- Conhecimento básico de terminal, controle de versões e CI/CD
2. Configuração do ambiente
Esta etapa faz um fork do repositório do app Leads CRM, clona no Cloud Shell, configura a CLI do Antigravity e faz a autenticação.
Bifurque o repositório
Você precisa da sua própria cópia do repositório porque vai enviar commits e criar solicitações de pull com o GitHub Actions.
Acesse o seguinte repositório
Em seguida, clique em Bifurcar. Na página de criação do fork, desmarque a caixa de seleção "Copiar apenas a ramificação main". Você precisa das outras ramificações de recursos (feature/lead-search e feature/bulk-operations) incluídas no fork.
Abra o Cloud Shell
Abra o Cloud Shell no navegador. O Cloud Shell oferece um ambiente pré-configurado com todas as ferramentas necessárias para este codelab. Clique em Autorizar quando solicitado a
Em seguida, clique em Visualizar -> Terminal para abrir o terminal.Sua interface vai ficar parecida com esta:
Essa será nossa interface principal, com o IDE na parte de cima e o terminal na parte de baixo.
Autenticar com o GitHub
Por padrão, o Cloud Shell não tem credenciais do GitHub configuradas, mas já tem a CLI gh instalada. Configure a autenticação para poder enviar commits e criar solicitações de pull mais tarde:
gh auth login
Selecionar Github.com
Selecione HTTPS ( ou escolha outro mecanismo se já estiver familiarizado com ele).
Em seguida, escolha Y
Em seguida, escolha Login with a web browser
**,**Você vai precisar copiar o código único e inseri-lo quando abrir a página de login no navegador. É possível Ctrl + Click no URL do terminal para abrir o URL https://github.com/login/device. Você vai precisar selecionar a conta em que quer fazer login e inserir o código.
Depois disso, volte para a página do console do Cloud Shell. Você vai ver a saída do terminal assim:
✓ Authentication complete. - gh config set -h github.com git_protocol https ✓ Configured git protocol ! Authentication credentials saved in plain text ✓ Logged in as alphinside-joonix
Isso significa que você configurou a autenticação da sua conta do GitHub no Cloud Shell.
Clone o repositório bifurcado
Em seguida, vamos clonar o repositório bifurcado. Substitua <YOUR_GITHUB_USERNAME> pelo nome de usuário do GitHub:
git clone https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo.git
cloudshell workspace leads-crm-app-demo && cd leads-crm-app-demo
Verificar ramificações de recursos
Depois disso, verifique se as duas ramificações de recursos com vulnerabilidades pré-criadas estão disponíveis no repositório remoto:
git branch -a | grep feature/
Você verá esta resposta
remotes/origin/feature/bulk-operations remotes/origin/feature/bulk-operations-solution remotes/origin/feature/email-composer remotes/origin/feature/lead-search
Verificar a CLI do Antigravity
Em seguida, vamos verificar se a CLI do Antigravity está pré-instalada no Cloud Shell. Verifique se ele está disponível:
agy --version
A versão instalada da CLI Antigravity vai aparecer.Por exemplo, 1.0.13.
Se você ainda não autenticou a CLI do Antigravity, acesse este codelab para conferir o processo de autenticação em mais detalhes.
Neste momento, você precisa ter o seguinte:
- o repositório bifurcado clonado
- as duas ramificações de recursos visíveis
- O comando
agyestá disponível e autenticado
3. O problema: vulnerabilidades ocultas em recursos codificados por vibração
Este é o cenário: um colega de equipe usou um agente de IA para adicionar dois recursos ao app Leads CRM: uma função de pesquisa de leads e operações de importação/exportação em massa. Os dois recursos funcionam. Ambos foram enviados rapidamente sem revisão de segurança. Você vai analisar as duas ramificações antes da fusão: uma de forma interativa com a CLI e outra automaticamente com uma ação do GitHub.
Examinar o primeiro branch de recurso
Revise a diferença em feature/lead-search:
git diff main...origin/feature/lead-search
Essa ramificação adiciona um endpoint de pesquisa. Analise o diff. Você vai encontrar problemas como concatenação de strings em consultas SQL, validação de entrada ausente, registro de depuração que vaza detalhes da consulta e mensagens de erro brutas expostas ao cliente.
+ app.get("/api/leads/search", (req, res) => {
+ const query = req.query.q as string;
+
+ if (!query) {
+ return res.status(400).json({ error: "Search query is required" });
+ }
...
Examinar a segunda ramificação de recurso
git diff main...origin/feature/bulk-operations
Essa ramificação adiciona endpoints de importação/exportação em massa e um painel de estatísticas de administrador. As vulnerabilidades incluem credenciais de administrador codificadas, endpoints de administrador não autenticados, falta de validação de entrada na importação em massa e risco de travessia de caminho no processamento de nomes de arquivos de exportação.
...
+ const ADMIN_PASSWORD = "admin123";
+
+ app.post("/api/admin/import", (req, res) => {
+ const { password, leads } = req.body;
+
+ if (password !== ADMIN_PASSWORD) {
+ return res.status(401).json({ error: "Invalid admin password" });
+ }
...
As duas ramificações adicionam recursos funcionais. Ambos têm problemas de segurança. A questão é como detectá-los: manualmente com a CLI (Caso 1) ou automaticamente com uma ação do GitHub (Caso 2).
4. Caso 1 : revisão interativa com a CLI do Antigravity
A revisão interativa da CLI é mais valiosa logo após uma sessão de programação de vibe, revisando o código que você acabou de escrever ou revisando a solicitação de pull dos seus colegas de equipe. Se estivermos falando de vibe coding, um agente de IA gerou seu código de recurso rapidamente, mas talvez você não entenda completamente cada linha produzida. Além disso, o agente pode ser otimizado para funcionalidade, e não necessariamente para segurança, dependendo da configuração de contexto durante o desenvolvimento do recurso.
Neste cenário, temos esses códigos com vulnerabilidades de segurança e vamos usar a CLI do Antigravity com habilidades de revisão de código para analisar o código de forma interativa. Esse padrão de agente-revisa-agente detecta vulnerabilidades que passam despercebidas quando a função do desenvolvedor muda de escrever código para aprovar código gerado por IA. Isso também se aplica ao revisar seu próprio código escrito manualmente ou a ramificação de um colega de equipe antes de passar pela CI. Você controla a conversa: peça ao agente para se concentrar em arquivos específicos, se aprofundar em uma descoberta ou aplicar correções imediatamente.
Sem capacidades de agente, a CLI do Antigravity ainda pode analisar o código, mas depende do conhecimento geral de treinamento, que pode não identificar padrões específicos do domínio ou aplicar critérios de revisão inconsistentes em diferentes sessões. As habilidades do agente oferecem um playbook estruturado: revisão de cinco eixos para qualidade e rotulagem de gravidade para priorização. A revisão se torna repetível e completa, não importa como você formule o comando.
Esta etapa usa a CLI do Antigravity com habilidades de agente para revisar a ramificação feature/lead-search, corrigir as vulnerabilidades e criar uma solicitação de pull limpa.
Confira o branch de recursos
Primeiro, vamos mudar nossa ramificação para a ramificação "Case 1":
git checkout feature/lead-search
Em seguida, vamos fazer upgrade da CLI do Antigravity com as habilidades do agente para fazer a revisão.
O que são habilidades do agente?
As habilidades são arquivos markdown declarativos que oferecem ao agente experiência especializada. Depois de instalados, eles se tornam comandos de barra (por exemplo, /code-review-and-quality). Pense neles como se você estivesse a um agente de uso geral um playbook de segurança de um engenheiro sênior.
As habilidades são portáteis entre agentes (Antigravity, Claude Code, Cursor etc.) e podem ser compartilhadas via Git. Para a CLI do Antigravity, as capacidades do espaço de trabalho (projeto/local) ficam em .agents/skills/ na raiz do projeto. Já as habilidades globais ficam em ~/.gemini/config/skills/. Saiba mais nesta documentação
Para demonstrar os recursos de habilidades do agente, este codelab vai usar a habilidade de revisão de código de addyosmani/agent-skills:
code-review-and-quality: revisão de cinco eixos (correção, legibilidade, arquitetura, segurança, desempenho) com rotulagem de gravidade.
Instalar a habilidade do agente de revisão de código
Usando o comando abaixo, a skill será instalada em .agents/skills/ por padrão no diretório de trabalho atual, uma instalação no nível do espaço de trabalho. Isso significa que eles se tornam parte do repositório e podem ser confirmados junto com seu código. Assim, todos os desenvolvedores (e o pipeline de CI) do projeto recebem automaticamente as mesmas habilidades de revisão.
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
Confira a habilidade detalhada que pode ser inspecionada no arquivo .agents/skills/code-review-and-quality/SKILL.md:
name: code-review-and-quality description: Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.
Principais recursos:
- Revisões em cinco eixos: correção, legibilidade, arquitetura, segurança e desempenho
- Rotula as descobertas por gravidade para que você corrija primeiro os problemas críticos
- Aplica o padrão de aprovação: "aprovar quando melhorar definitivamente a integridade geral do código, mesmo que não seja perfeito".
Agora estamos prontos para executar. Vamos verificar a habilidade na CLI do Antigravity
Iniciar a AGY e verificar as habilidades
Vamos executar a CLI do Antigravity
agy --dangerously-skip-permissions
Em seguida, execute o comando a seguir
/skills
As duas habilidades vão aparecer assim em Workspace habilidades
Executar a revisão de código da diferença de recursos
Invoque a habilidade de segurança e peça para ela analisar sua ramificação. Digite este comando:
Review the git diff between main and my current branch. Find any issues based on the agent skills that are appropriate for this. Write the findings and plan to fix them to code_review.md in the current working directory. Do not apply fixes yet.
O agente detecta e ativa automaticamente a habilidade code-review-and-quality relevante. Ele lê o diff, identifica vulnerabilidades e escreve as descobertas com um plano de correção proposto para code_review.md.
Depois que a verificação terminar, você verá o arquivo code_review.md criado no diretório de trabalho e poderá inspecioná-lo no editor.
Revise cada descoberta e a correção proposta. Quando o plano estiver pronto, peça ao agente para aplicá-lo:
Apply the proposed fixes from code_review.md
O agente lê o plano e aplica cada correção planejada aos arquivos de origem.
Agora, se quiser, verifique se o app está funcionando corretamente ou não após a correção instalando as dependências e executando-o.
npm install
npm run dev
O aplicativo precisa funcionar corretamente. Caso contrário, você pode iterar e pedir para a CLI do Antigravity corrigir o problema.
Fazer commit e criar uma solicitação de pull
Agora, se quiser, você pode enviar as mudanças para seu próprio repositório. Antes de passar para o próximo caso, vamos confirmar as mudanças na ramificação atual.
Primeiro, configure sua identidade do Git (substitua pelo seu nome e e-mail), se ainda não tiver feito isso:
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
Em seguida, faça commit das mudanças.
git add .
git commit -m "fix: address security vulnerabilities in lead search feature"
Agora, você já usou a CLI do Antigravity como um revisor interativo. As habilidades deram a ele uma metodologia estruturada: revisão de código de cinco eixos. Isso funciona quando você é o desenvolvedor que está revisando o código gerado por IA, o seu próprio ou a contribuição de um colega de equipe. Na próxima seção, vamos automatizar todo esse fluxo para transformá-lo em um processo automatizado escalonável no seu repositório de código usando o GitHub como exemplo.
5. Caso 2 : revisão automatizada com o SDK Antigravity – Parte 1 ( criação do agente)
Esta etapa cria um agente de análise automática usando o SDK do Antigravity, implanta como uma ação do GitHub e testa na segunda ramificação de recurso. O agente analisa as solicitações de pull sob demanda e posta as descobertas como comentários.
Por que a análise automática?
A revisão interativa da CLI (caso 1) funciona quando um desenvolvedor faz uma revisão ativa. As equipes precisam de uma revisão que seja executada automaticamente em cada solicitação de pull, detectando problemas de qualquer colaborador, ferramenta e a qualquer momento. O SDK do Antigravity (google-antigravity) oferece o mesmo tempo de execução do agente que a CLI, como uma biblioteca Python. As políticas e os hooks são configurados em código.
O GitHub Actions é a plataforma de integração contínua/desenvolvimento contínuo (CI/CD) integrada do GitHub. Ele executa fluxos de trabalho (scripts automatizados definidos em YAML) em resposta a eventos do repositório, como abrir uma solicitação de pull, enviar um commit ou postar um comentário. Os fluxos de trabalho são executados em máquinas virtuais hospedadas no GitHub e têm acesso ao código do repositório. Nesse caso, você usa uma ação do GitHub para executar um agente de revisão de segurança sempre que uma solicitação de envio é criada.
Veja como funciona o fluxo de análise automática:
O SDK do Antigravity ( google-antigravity) oferece o mesmo tempo de execução do agente que a CLI, como uma biblioteca Python. Você escreve um script Python que configura o agente com políticas e hooks, executa-o em uma ação do GitHub e posta os resultados como um comentário de PR.
Gerar uma chave de API Gemini
Antes de começar, vamos precisar da chave de API Gemini para ser usada pelo SDK do Antigravity. Acesse Chave de API do Google AI Studio e crie uma chave de API. Copie a chave sempre que necessário.
Essa chave será usada ao executar o agente de revisão localmente e como um secret do GitHub Actions mais tarde.
Parte A: criar o agente de revisão
Agora, para o caso 2, mude o diretório de trabalho atual para a ramificação feature/bulk-operations:
git checkout feature/bulk-operations
Essa é a segunda ramificação de recurso do cenário. Ela adiciona endpoints de importação/exportação em massa e um painel de estatísticas de administrador ao app de CRM.
Configurar o projeto Python
No momento, o SDK do Antigravity está disponível apenas em Python. Portanto, vamos precisar de um ambiente Python para desenvolvê-lo. Vamos usar uv para nosso gerenciador de projetos Python. O uv é um gerenciador rápido de pacotes e projetos do Python escrito em Rust ( documentos). Este codelab usa essa opção para simplificar e agilizar o processo. Se você usar o Cloud Shell neste tutorial, ele já estará pré-instalado na instância. Consulte este tutorial se quiser instalar para seu
Inicialize um projeto Python para o agente de revisão usando uv:
uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7
Isso vai criar um novo diretório code_review_agent que vai conter os arquivos necessários do agente de revisão de código.
Instalar as habilidades de revisão
O agente de revisão precisa das mesmas habilidades de segurança e revisão de código usadas no caso 1. Instale-os em code_review_agent/skills/ para que o agente do SDK os carregue durante a execução:
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills
Criar o agente de revisão
Agora, vamos criar code_review_agent/review_agent.py . Execute este comando
cloudshell edit code_review_agent/review_agent.py
Em seguida, copie o conteúdo abaixo para o arquivo
#!/usr/bin/env python3
import asyncio
import json
import os
import sys
import pydantic
from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
from google.antigravity.hooks import hooks, policy
from google.antigravity import types
class Finding(pydantic.BaseModel):
file: str
line: int
severity: str
category: str
description: str
proposed_fix: str = ""
class ReviewResult(pydantic.BaseModel):
findings: list[Finding]
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_FILE = "code_review.md"
SKILLS_PATHS = [
os.path.join(SCRIPT_DIR, "skills", "code-review-and-quality"),
]
review_policies = [
policy.deny_all(),
policy.allow("view_file"),
policy.allow("list_directory"),
policy.allow("search_directory"),
policy.allow("find_file"),
policy.allow("run_command"),
policy.allow("finish"),
]
@hooks.post_tool_call
async def log_tool_results(data: types.ToolResult):
result_str = str(data.result) if data.result else ""
preview = result_str[:200] + "..." if len(result_str) > 200 else result_str
print(f"[audit] tool={data.name} result_len={len(result_str)} error={data.error} preview={preview}", flush=True)
@hooks.pre_tool_call_decide
async def enforce_safe_tools(data: types.ToolCall) -> types.HookResult:
print(f"[audit] calling tool={data.name} args_keys={list(data.args.keys())}", flush=True)
if data.name == "run_command":
cmd = str(data.args.get("CommandLine", ""))
if not cmd.startswith("git "):
return types.HookResult(
allow=False,
message=f"Only git commands are allowed. Blocked: {cmd}"
)
return types.HookResult(allow=True)
async def review_code(target_dir: str) -> dict:
prompt = f"""Run `git diff main...HEAD -- ':!.github' ':!code_review_agent'` in {target_dir} to get the changes on this branch.
Review ONLY the changed code for security vulnerabilities and code quality issues.
"""
config_kwargs = dict(
system_instructions=(
"You are a code review agent. "
"You review code diffs for vulnerabilities and quality issues using the loaded skills. "
"You can run git commands to inspect the diff. "
"You NEVER modify files."
),
response_schema=ReviewResult,
skills_paths=SKILLS_PATHS,
policies=review_policies,
hooks=[log_tool_results, enforce_safe_tools],
)
if os.environ.get("GEMINI_API_KEY"):
config_kwargs["api_key"] = os.environ["GEMINI_API_KEY"]
else:
config_kwargs["vertex"] = True
config_kwargs["project"] = os.environ.get("GOOGLE_CLOUD_PROJECT")
config_kwargs["location"] = os.environ.get("GOOGLE_CLOUD_LOCATION", "global")
config = LocalAgentConfig(**config_kwargs)
async with Agent(config) as agent:
response = await agent.chat(prompt)
last_step = -1
final_text_chunks = []
async for chunk in response.chunks:
if isinstance(chunk, types.ToolCall):
final_text_chunks.clear()
if hasattr(chunk, "text") and hasattr(chunk, "step_index"):
if chunk.step_index != last_step:
final_text_chunks.clear()
last_step = chunk.step_index
final_text_chunks.append(chunk.text)
final_text = "".join(final_text_chunks)
if final_text:
print(final_text)
data = await response.structured_output()
if data and "findings" in data:
return {"findings": data["findings"]}
try:
parsed = json.loads(final_text)
if isinstance(parsed, list):
return {"findings": parsed}
if isinstance(parsed, dict) and "findings" in parsed:
return {"findings": parsed["findings"]}
except json.JSONDecodeError:
pass
return {"findings": final_text}
SEVERITY_EMOJI = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵"}
def format_markdown(result: dict) -> str:
findings = result.get("findings", [])
if isinstance(findings, str):
return f"## AI Security Review\n\n{findings}\n"
if not findings:
return "## AI Security Review\n\nNo security issues found.\n"
lines = ["## AI Security Review\n"]
for f in findings:
emoji = SEVERITY_EMOJI.get(f.get("severity", "").lower(), "⚪")
lines.append(f"### {emoji} [{f.get('severity', 'unknown').upper()}] {f.get('category', '')}\n")
lines.append(f"**{f.get('file', '')}:{f.get('line', '')}**\n")
lines.append(f"{f.get('description', '')}\n")
proposed_fix = f.get('proposed_fix', '')
if proposed_fix:
lines.append(f"**Proposed fix:** {proposed_fix}\n")
lines.append("---\n*Powered by Antigravity SDK*")
return "\n".join(lines)
if __name__ == "__main__":
target = sys.argv[1] if len(sys.argv) > 1 else "."
result = asyncio.run(review_code(target))
markdown = format_markdown(result)
with open(OUTPUT_FILE, "w") as f:
f.write(markdown)
print(f"Review written to {OUTPUT_FILE}")
print(json.dumps(result, indent=2))
Confira as principais decisões de design neste agente:
- Políticas de negação por padrão:
policy.deny_all()bloqueia tudo e permite especificamente apenas ferramentas de leitura de arquivos abertos erun_command(para git). - Aplicação em duas camadas: as políticas restringem no nível da framework, e o hook
enforce_safe_toolsfornece uma segunda camada, permitindo apenas comandosgitporrun_command. - Escopo de diff do Git: o agente executa
git diff main...HEADpara revisar apenas o código alterado, não toda a base de código. - Saída estruturada com substituição:
response_schema=ReviewResultaplica a estrutura JSON usando a ferramenta de conclusão do SDK. Se a análise falhar, a cadeia de substitutos tentará analisartext()como JSON e retornará texto bruto. - Fallback de autenticação: usa
GEMINI_API_KEYse disponível. Caso contrário, volta para a Vertex AI usando o Application Default Credentials. - Saída de arquivo: grava descobertas formatadas em Markdown em
code_review.md. A ação do GitHub lê esse arquivo e o posta como um comentário de PR mais tarde.
Testar o agente de revisão
Teste na raiz do projeto. O SDK vai ler GEMINI_API_KEY do ambiente. Portanto, vamos colocar a chave no ambiente.
export GEMINI_API_KEY=YOUR_API_KEY
Em seguida, execute o comando a seguir para executar localmente
uv run --project code_review_agent code_review_agent/review_agent.py .
Durante a execução, ele vai mostrar uma saída do console explicando quais ferramentas estão sendo usadas. Você pode notar isso acessando as habilidades do agente security-and-hardening e code-review-and-quality.
[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile'] [audit] tool=view_file result_len=47 error=None preview=Read security and hardening skill documentation [audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile'] [audit] tool=view_file result_len=48 error=None preview=Read code review and quality skill documentation [audit] calling tool=run_command args_keys=['CommandLine', 'Cwd', 'WaitMsBeforeAsync'] ...
O agente executa git diff main...HEAD, revisa apenas o código alterado, grava descobertas formatadas em code_review.md e imprime JSON estruturado no console. Você pode inspecionar o code_review.md escrito no editor, como mostrado abaixo.
Localmente, ele já está funcionando. Agora vamos para a próxima parte. Como criar a configuração do GitHub Action
6. Caso 2 : análise automatizada com o SDK Antigravity – Parte 2 ( configuração das ações do GitHub)
Antes de começar, exclua o arquivo code_review.md produzido anteriormente, se ele existir.
rm -f code_review.md
Agora, vamos criar o arquivo de configuração YAML do GitHub Action.
mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml
Depois, adicione o seguinte conteúdo ao arquivo:
name: AI Code Security and Quality Review
on:
pull_request:
types: [opened, synchronize]
jobs:
review:
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: write
container:
image: ghcr.io/astral-sh/uv:python3.12-bookworm
steps:
- name: Install git
run: apt-get update && apt-get install -y git
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Run security review
env:
GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
run: |
git config --global --add safe.directory $GITHUB_WORKSPACE
uv run --project code_review_agent code_review_agent/review_agent.py .
- name: Post findings as PR comment
if: always()
uses: actions/github-script@v7
with:
script: |
const fs = require('fs');
const body = fs.readFileSync('code_review.md', 'utf8');
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.payload.pull_request.number,
body: body
});
O fluxo de trabalho será acionado automaticamente quando uma PR for aberta ou atualizada. Ele faz o check-out da ramificação de solicitação de pull com o histórico completo do Git (necessário para git diff main...HEAD), executa o agente de revisão que grava descobertas em code_review.md e posta o conteúdo do arquivo como um comentário de solicitação de pull.
Agora vamos confirmar todas as mudanças e enviar para o GitHub remoto. Estamos prontos para testar essa integração.
git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations
7. Caso 2 : revisão automatizada com o SDK do Antigravity – Parte 3 (teste de revisão de código automatizada)
Agora, acesse a página da Web do repositório bifurcado https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo e clique em Settings.
Em seguida, no painel à esquerda, encontre Secrets and variables e clique em Actions.
Depois disso, clique em New repository secret para configurar o segredo GEMINI_API_KEY.
Depois disso, selecione Pull Request e crie uma solicitação de envio da ramificação feature/bulk_operations para a ramificação main do seu próprio repositório.
Depois que a solicitação de pull for criada, ela vai executar as ações do GitHub, que podem ser inspecionadas no menu Checks ou perto do botão Merge pull request.
Clique nas ações em execução para ver os detalhes. Quando terminar, os resultados da revisão serão postados como um comentário de solicitação de pull, conforme mostrado abaixo.
8. Conclusão
Parabéns!
Você criou dois fluxos de trabalho completos de revisão de código para detectar vulnerabilidades de segurança em recursos codificados em vibe:
- Caso 1 (interativo): a CLI do Antigravity com habilidades de agente analisou um diff de ramificação de recurso, identificou injeção de SQL e outras vulnerabilidades, corrigiu-as seguindo padrões do OWASP e produziu uma solicitação de pull limpa.
- Caso 2 (automatizado): o SDK do Antigravity alimentou uma ação do GitHub que revisa automaticamente todas as solicitações de envio, postando descobertas de segurança estruturadas como comentários de solicitação de envio.
O que você aprendeu
- Como a programação de vibrações cria riscos de segurança e por que a análise automatizada detecta o que a análise manual não detecta
- Como instalar e usar habilidades de agente para dar à CLI do Antigravity experiência estruturada em segurança
- Como revisar interativamente uma ramificação de recurso, corrigir problemas e criar uma solicitação de pull limpa
- Como criar um agente de revisão somente leitura com o SDK do Antigravity usando políticas de negação por padrão e hooks de ciclo de vida
- Como implantar um pipeline de análise automática como uma ação do GitHub com suporte interativo de acompanhamento
Limpeza
Fechar as solicitações de pull
Acesse cada solicitação de pull no seu fork no GitHub e clique em Fechar solicitação de pull. Não faça o merge da solicitação de pull feature/bulk-operations. Ela ainda contém o código vulnerável sem patch.
Exclua o repositório bifurcado (opcional)
Se você não precisar mais do fork, acesse Configurações -> role até Zona de perigo -> Excluir este repositório.
A seguir
- Plug-ins e habilidades da CLI do Antigravity: crie habilidades e plug-ins personalizados.
- Permissões e sandbox da CLI do Antigravity: políticas de ferramentas refinadas e sandbox no nível do SO.
- Hooks e políticas do SDK do Antigravity: padrões avançados (limitação de taxa, recuperação de erros, middleware)
- Exemplos do SDK do Antigravity:
agent_middleware.pypara padrões de produção