1. Introduzione
Il vibe coding, ovvero l'utilizzo di agenti AI per scrivere codice a partire da prompt in linguaggio naturale, sposta il ruolo dello sviluppatore da autore a orchestratore e revisore. Ci affidiamo alla preparazione del contesto perfetto e ci fidiamo degli agenti AI per fare tutto per noi, dalla creazione dei documenti di specifiche fino a garantire che il codice soddisfi tutti i requisiti. Il rischio: in cicli di iterazione rapidi, il codice funzionale viene approvato senza un'attenta revisione della sicurezza. Gli agenti moderni spesso producono codice sicuro per impostazione predefinita, ma "spesso" non significa "sempre" e le vulnerabilità accumulate sfuggono alla revisione manuale.
Questo codelab risolve questi problemi insegnando due approcci all'utilizzo di Antigravity come revisore: in modo interattivo durante lo sviluppo con la CLI (tu rivedi, correggi e poi PR) e automaticamente nell'integrazione continua con l'SDK (l'agente rivede ogni richiesta di pull e pubblica i risultati come commento).
Argomenti trattati
Hai creato un'app CRM per i lead con la codifica vibrazionale e un agente AI ha creato lo stack completo per te: backend Express, database SQLite, frontend React. Funziona. Poi hai chiesto all'agente di aggiungere due nuove funzionalità: una funzione di ricerca dei lead e l'importazione/esportazione collettiva con statistiche amministrative. L'agente ha consegnato entrambi rapidamente. Il codice viene eseguito, le funzionalità funzionano e le PR sono pronte.
Ma ecco il problema: non hai scritto questo codice. L'hai approvata. Come fai a sapere che l'endpoint di ricerca non è vulnerabile all'SQL injection? Come fai a sapere che la route di amministrazione non ha una password hardcoded? Non è necessario e leggere ogni riga di codice generato dall'AI vanifica il vantaggio di velocità che ti ha spinto a utilizzare il vibe coding.
Questo codelab ti offre due modi per risolvere il problema:
- Caso 1: revisione interattiva. Estrai un ramo di funzionalità con vulnerabilità, utilizza Antigravity CLI migliorata con le competenze dell'agente per esaminare le differenze, correggere i problemi e creare una richiesta di pull pulita.
- Scenario 2: revisione automatizzata: configura un'azione GitHub basata sull'Antigravity SDK che esamina automaticamente le richieste di pull, pubblica i risultati strutturati come commenti e risponde quando gli sviluppatori pongono domande di follow-up sulla revisione.
Cosa imparerai a fare
- In che modo il vibe coding può creare rischi per la sicurezza e perché la revisione automatizzata rileva ciò che la revisione manuale non rileva
- Come installare e utilizzare le skill degli agenti gestite dalla community per fornire all'Antigravity CLI competenze approfondite in materia di sicurezza e revisione del codice
- Come utilizzare l'interfaccia a riga di comando in modo interattivo per esaminare la differenza di un ramo della funzionalità, correggere le vulnerabilità e creare una richiesta di pull pulita
- Come utilizzare l'SDK Antigravity per creare un agente di revisione del codice di sola lettura con policy di sicurezza dichiarative e hook del ciclo di vita
- Come eseguire il deployment dell'agente di revisione come azione GitHub che esamina le richieste di pull e pubblica il risultato come commento alla richiesta di pull
Prerequisiti
- Un account Google Cloud
- Un account GitHub
- Familiarità di base con Terminale, controllo delle versioni e CI/CD
2. Configurazione dell'ambiente
Questo passaggio crea un fork del repository dell'app CRM Lead, lo clona in Cloud Shell, configura Antigravity CLI ed esegue l'autenticazione.
Crea un fork del repository
Ti serve una tua copia del repository perché eseguirai il push dei commit e creerai richieste di pull con GitHub Actions.
Vai al seguente repository
Quindi, fai clic su Fork. Nella pagina di creazione del fork, deseleziona la casella di controllo "Copia solo il ramo main". Devi includere gli altri rami delle funzionalità (feature/lead-search e feature/bulk-operations) nel fork.
Apri Cloud Shell
Apri Cloud Shell nel browser. Cloud Shell fornisce un ambiente preconfigurato con tutti gli strumenti necessari per questo codelab. Quando richiesto, fai clic su Autorizza.
Poi fai clic su "Visualizza" -> "Terminale" per aprire il terminale.L'interfaccia dovrebbe avere un aspetto simile a questo
Questa sarà la nostra interfaccia principale, con l'IDE in alto e il terminale in basso.
Autenticazione con GitHub
Per impostazione predefinita, Cloud Shell non ha credenziali GitHub configurate, ma ha già installato gh CLI. Configura l'autenticazione per poter eseguire il push dei commit e creare richieste di pull in un secondo momento:
gh auth login
Seleziona Github.com
Seleziona HTTPS ( o scegli un altro meccanismo se lo conosci già).
Poi scegli Y.
Poi scegli Login with a web browser.
**,**Ti verrà chiesto di copiare il codice monouso e di inserirlo quando apri la pagina di accesso nel browser. Puoi Ctrl + Click sull'URL nel terminale per aprire l'URL https://github.com/login/device. Ti verrà chiesto di selezionare l'account a cui vuoi accedere e di inserire il codice.
Dopodiché, torna alla pagina della console Cloud Shell e vedrai l'output del terminale come questo
✓ 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
Ciò significa che hai configurato correttamente l'autenticazione dell'account GitHub su Cloud Shell.
Clona il repository di cui hai creato un fork
Ora cloniamo il repository creato con fork. Sostituisci <YOUR_GITHUB_USERNAME> con il tuo nome utente 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
Verificare i rami delle funzionalità
Dopodiché, verifica che entrambi i rami delle funzionalità con vulnerabilità predefinite siano disponibili nel repository remoto:
git branch -a | grep feature/
Dovresti vedere l'output seguente
remotes/origin/feature/bulk-operations remotes/origin/feature/bulk-operations-solution remotes/origin/feature/email-composer remotes/origin/feature/lead-search
Verifica Antigravity CLI
Successivamente, verifichiamo che Antigravity CLI sia preinstallato in Cloud Shell. Verifica che sia disponibile:
agy --version
Dovresti visualizzare la versione di Antigravity CLI installata, ad esempio 1.0.13
Ora, se non hai ancora autenticato la CLI Antigravity, puoi consultare questo codelab per vedere la procedura di autenticazione in modo più dettagliato.
A questo punto dovresti avere quanto segue:
- il repository forked clonato
- entrambe le diramazioni delle funzionalità visibili
- Comando
agydisponibile e autenticato
3. Il problema: vulnerabilità nascoste nelle funzionalità con codifica a vibrazione
Ecco lo scenario: un collega ha utilizzato un agente AI per aggiungere due funzionalità all'app CRM Leads: una funzione di ricerca dei lead e operazioni di importazione/esportazione collettiva. Entrambe le funzionalità funzionano. Entrambi sono stati spediti rapidamente senza revisione della sicurezza. Esaminerai entrambi i rami prima che vengano uniti: uno in modo interattivo con la CLI, l'altro automaticamente con un'azione GitHub.
Esamina il primo ramo della funzionalità
Esamina la differenza in feature/lead-search:
git diff main...origin/feature/lead-search
Questo ramo aggiunge un endpoint di ricerca. Esamina la differenza: dovresti individuare problemi come la concatenazione di stringhe nelle query SQL, la convalida dell'input mancante, la registrazione di debug che rivela i dettagli della query e i messaggi di errore non elaborati esposti al client.
+ 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" });
+ }
...
Esamina il secondo ramo delle funzionalità
git diff main...origin/feature/bulk-operations
Questo ramo aggiunge endpoint di importazione/esportazione collettiva e una dashboard delle statistiche amministrative. Le vulnerabilità includono credenziali amministrative hardcoded, endpoint amministrativi non autenticati, nessuna convalida dell'input per l'importazione collettiva e rischio di path traversal nella gestione dei nomi dei file di esportazione.
...
+ 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" });
+ }
...
Entrambi i rami aggiungono funzionalità. Entrambi presentano problemi di sicurezza. La domanda è come rilevarli: manualmente con la CLI (caso 1) o automaticamente con un'azione GitHub (caso 2).
4. Caso 1 : revisione interattiva con Antigravity CLI
La revisione interattiva della CLI è più utile subito dopo una sessione di codifica delle vibrazioni, per rivedere il codice appena scritto o la richiesta di pull dei tuoi compagni di squadra. Se parliamo di vibe coding, un agente AI ha generato rapidamente il codice della funzionalità, ma potresti non comprendere appieno ogni riga prodotta e l'agente potrebbe essere ottimizzato per la funzionalità e non necessariamente per la sicurezza, a seconda della configurazione del contesto durante lo sviluppo della funzionalità.
In questo scenario, abbiamo questi codici con vulnerabilità di sicurezza e utilizzeremo Antigravity CLI con competenze di revisione del codice per esaminare il codice in modo interattivo. Questo pattern di revisione dell'agente rileva le vulnerabilità che sfuggono quando il ruolo dello sviluppatore passa dalla scrittura del codice all'approvazione del codice generato dall'AI. Si applica anche quando esamini il codice scritto manualmente o il ramo di un membro del team prima che venga sottoposto a integrazione continua. Controlla la conversazione: chiedi all'agente di concentrarsi su file specifici, approfondire un risultato o applicare immediatamente le correzioni.
Senza le competenze dell'agente, Antigravity CLI può comunque esaminare il codice, ma si basa sulle sue conoscenze di addestramento generali, che potrebbero non rilevare pattern specifici del dominio o applicare criteri di revisione incoerenti tra le sessioni. Le competenze dell'agente forniscono a quest'ultimo un playbook strutturato: revisione a cinque assi per la qualità, etichettatura della gravità per la definizione delle priorità. La revisione diventa ripetibile e approfondita, indipendentemente da come formuli il prompt.
Questo passaggio utilizza l'interfaccia a riga di comando Antigravity con le competenze dell'agente per esaminare il ramo feature/lead-search, correggere le vulnerabilità e creare una richiesta di pull pulita.
Dai un'occhiata al ramo della funzionalità
Innanzitutto, cambiamo il ramo con il ramo Case 1:
git checkout feature/lead-search
Poi, eseguiamo l'upgrade della nostra Antigravity CLI con le skill dell'agente per eseguire la revisione
Che cosa sono le competenze dell'agente
Le skill sono file Markdown dichiarativi che forniscono all'agente competenze specializzate. Una volta installati, diventano comandi slash (ad es. /code-review-and-quality). Considerali come se fornissero a un agente per uso generico il playbook di sicurezza di un ingegnere senior.
Le competenze sono portabili tra gli agenti (Antigravity, Claude Code, Cursor ecc.) e condivisibili tramite Git. Per Antigravity CLI, le skill del workspace (progetto/locale) si trovano in .agents/skills/ nella radice del progetto. mentre le competenze globali si trovano in ~/.gemini/config/skills/. Scopri di più in questa documentazione.
Per dimostrare le funzionalità delle competenze degli agenti, questo codelab utilizzerà la competenza di revisione del codice di addyosmani/agent-skills:
code-review-and-quality: revisione a cinque assi (correttezza, leggibilità, architettura, sicurezza, prestazioni) con etichettatura della gravità.
Installare la skill dell'agente di revisione del codice
Utilizzando il comando riportato di seguito, la skill verrà installata in .agents/skills/ per impostazione predefinita nella directory di lavoro corrente, ovvero un'installazione a livello di spazio di lavoro. Ciò significa che diventano parte del repository e possono essere inviati insieme al codice, in modo che ogni sviluppatore (e pipeline CI) del progetto ottenga automaticamente le stesse competenze di revisione.
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
Ecco la competenza dettagliata che può essere esaminata nel file .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.
Funzionalità chiave:
- Revisioni su cinque assi: correttezza, leggibilità, architettura, sicurezza e prestazioni
- Etichetta i risultati in base alla gravità, in modo da risolvere prima i problemi critici
- Applica lo standard di approvazione: "approva quando migliora sicuramente l'integrità complessiva del codice, anche se non è perfetto".
Ora siamo pronti per l'esecuzione. Verifichiamo la skill nella CLI Antigravity
Avvia AGY e verifica le competenze
Eseguiamo Antigravity CLI
agy --dangerously-skip-permissions
Quindi esegui questo comando
/skills
Dovresti vedere le due competenze visualizzate in questo modo nella sezione Workspace competenze
Esegui la revisione del codice della differenza della funzionalità
Invoca la skill di sicurezza e chiedi di esaminare la tua filiale. Digita questo prompt:
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.
L'agente rileva la skill code-review-and-quality pertinente e la attiva automaticamente. Legge la differenza, identifica le vulnerabilità e scrive i risultati con un piano di correzione proposto per code_review.md.
Al termine della scansione, dovresti visualizzare il file code_review.md creato nella directory di lavoro e puoi esaminarlo nell'editor.
Esamina ogni risultato e la correzione proposta. Quando il piano ti soddisfa, chiedi all'agente di applicarlo:
Apply the proposed fixes from code_review.md
L'agente legge il piano e applica ogni correzione pianificata ai file di origine.
Ora, se vuoi, puoi verificare se l'app funziona correttamente o meno dopo la correzione installando le dipendenze ed eseguendola.
npm install
npm run dev
L'applicazione dovrebbe funzionare correttamente. In caso contrario, puoi iterare e chiedere ad Antigravity CLI di risolvere il problema.
Esegui il commit e crea una richiesta pull
Ora, se vuoi, puoi eseguire il push delle modifiche nel tuo repository. Prima di passare al caso successivo, esegui il commit delle modifiche nel ramo corrente.
Se non l'hai ancora fatto, devi configurare la tua identità Git (sostituisci con il tuo nome e indirizzo email):
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
Poi esegui il commit delle modifiche.
git add .
git commit -m "fix: address security vulnerabilities in lead search feature"
Ora hai già utilizzato Antigravity CLI come revisore interattivo. Le competenze gli hanno fornito una metodologia strutturata: la revisione del codice a cinque assi. Questa funzionalità è utile quando sei lo sviluppatore che esamina il codice generato dall'AI, il tuo o il contributo di un membro del team. Nella sezione successiva, automatizzeremo l'intero flusso per renderlo un processo automatizzato scalabile nel tuo repository di codice utilizzando GitHub come esempio.
5. Scenario 2 : revisione automatizzata con l'SDK Antigravity - Parte 1 ( creazione dell'agente)
Questo passaggio crea un agente di revisione automatizzato utilizzando l'SDK Antigravity, lo esegue il deployment come azione GitHub e lo testa rispetto al secondo ramo della funzionalità. L'agente esamina le PR su richiesta e pubblica i risultati come commenti alle PR.
Perché la revisione automatizzata
La revisione interattiva della CLI (caso 1) funziona quando uno sviluppatore esegue una revisione attiva. I team hanno bisogno di una revisione che venga eseguita automaticamente su ogni richiesta di pull, rilevando i problemi di qualsiasi collaboratore, strumento e in qualsiasi momento. L'SDK Antigravity (google-antigravity) fornisce lo stesso runtime dell'agente della CLI come libreria Python. I criteri e gli hook sono configurati nel codice.
GitHub Actions è la piattaforma di integrazione continua/sviluppo continuo (CI/CD) integrata di GitHub. Esegue flussi di lavoro, ovvero script automatizzati definiti in YAML, in risposta a eventi del repository come l'apertura di una richiesta di pull, il push di un commit o la pubblicazione di un commento. I workflow vengono eseguiti su macchine virtuali ospitate su GitHub e hanno accesso al codice del repository. In questo caso, utilizzi un'azione GitHub per eseguire un agente di revisione della sicurezza ogni volta che viene creata una richiesta di pull.
Ecco come funziona il flusso di revisione automatizzata:
L'SDK Antigravity ( google-antigravity) fornisce lo stesso runtime dell'agente della CLI come libreria Python. Scrivi uno script Python che configura l'agente con criteri e hook, lo esegui all'interno di un'azione GitHub e pubblica i risultati come commento alla richiesta di pull.
Ottieni una chiave API Gemini
Prima di iniziare, avremo bisogno della chiave API Gemini da utilizzare con l'Antigravity SDK. Vai a Chiave API Google AI Studio e crea una chiave API. Se necessario, puoi copiarla.
Questa chiave verrà utilizzata quando esegui l'agente di revisione localmente e in un secondo momento come secret di GitHub Actions
Parte A: crea l'agente di revisione
Ora, per lo scenario 2, passiamo dalla directory di lavoro attuale al ramo feature/bulk-operations:
git checkout feature/bulk-operations
Questo è il secondo ramo di funzionalità dello scenario: aggiunge endpoint di importazione/esportazione collettiva e una dashboard delle statistiche amministrative all'app CRM.
Configurare il progetto Python
L'SDK Antigravity è attualmente disponibile solo in Python, quindi avremo bisogno di un ambiente Python per svilupparlo. Utilizzeremo uv per il nostro project manager Python. uv è un gestore di pacchetti e progetti Python veloce scritto in Rust ( documenti). Questo codelab lo utilizza per velocità e semplicità. Se utilizzi Cloud Shell per questo tutorial, è già preinstallato nell'istanza. Consulta questo tutorial se vuoi installarlo per il tuo
Inizializza un progetto Python per l'agente di revisione utilizzando uv:
uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7
Verrà creata una nuova directory code_review_agent che conterrà i file necessari dell'agente di revisione del codice.
Installare le skill di recensione
L'agente di revisione deve avere le stesse competenze di revisione del codice e di sicurezza utilizzate nel caso 1. Installali in code_review_agent/skills/ in modo che l'agente SDK li carichi in fase di runtime:
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills
Crea l'agente di revisione
Ora creiamo code_review_agent/review_agent.py . Esegui questo comando
cloudshell edit code_review_agent/review_agent.py
Poi copia i seguenti contenuti nel file
#!/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))
Esamina le decisioni di progettazione chiave in questo agente:
- Policy di negazione predefinita:
policy.deny_all()blocca tutto, poi consente specificamente solo gli strumenti di lettura dei file erun_command(per Git). - Applicazione a due livelli: i criteri limitano a livello di framework e l'hook
enforce_safe_toolsfornisce un secondo livello, consentendo solo i comandigittramiterun_command. - Ambito di Git diff: l'agente esegue
git diff main...HEADper esaminare solo il codice modificato, non l'intero codebase. - Output strutturato con fallback:
response_schema=ReviewResultimpone la struttura JSON tramite lo strumento di completamento dell'SDK. Se l'analisi non va a buon fine, la catena di riserva tenta di analizzaretext()come JSON, poi restituisce il testo non elaborato. - Fallback dell'autenticazione: utilizza
GEMINI_API_KEYse disponibile, altrimenti esegue il fallback a Vertex AI tramite le credenziali predefinite dell'applicazione. - Output file: scrive i risultati in formato Markdown in
code_review.md. L'azione GitHub legge questo file e lo pubblica in un secondo momento come commento alla richiesta di pull.
Testare l'agente di revisione
Esegui il test dalla radice del progetto. L'SDK leggerà GEMINI_API_KEY dall'ambiente, quindi inseriamo la chiave nell'ambiente
export GEMINI_API_KEY=YOUR_API_KEY
Quindi esegui questo comando per eseguirlo localmente:
uv run --project code_review_agent code_review_agent/review_agent.py .
Durante l'esecuzione, viene visualizzato un output della console che spiega quali strumenti vengono attualmente utilizzati. Puoi notarlo accedendo alle skill dell'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'] ...
L'agente esegue git diff main...HEAD, esamina solo il codice modificato, scrive i risultati formattati in code_review.md e stampa JSON strutturato nella console. Puoi esaminare il code_review.md scritto nell'editor come mostrato di seguito
Localmente funziona già, quindi passiamo alla parte successiva. Creazione della configurazione dell'azione GitHub
6. Scenario 2 : revisione automatica con l'SDK Antigravity - Parte 2 ( configurazione di GitHub Actions)
Prima di iniziare, eliminiamo il file code_review.md prodotto in precedenza, se esiste.
rm -f code_review.md
Ora dobbiamo creare il file di configurazione YAML di GitHub Action.
mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml
Aggiungi poi i seguenti contenuti al file
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
});
Il flusso di lavoro verrà attivato automaticamente quando viene aperta o aggiornata una richiesta pull. Estrae il ramo della richiesta di pull con la cronologia git completa (necessaria per git diff main...HEAD), esegue l'agente di revisione che scrive i risultati in code_review.md e pubblica i contenuti del file come commento alla richiesta di pull.
Ora eseguiamo il commit di tutte le modifiche e inviamole al repository remoto di GitHub. Siamo pronti a testare questa integrazione.
git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations
7. Scenario 2 : revisione automatizzata con l'SDK Antigravity - Parte 3 (test della revisione automatizzata del codice)
Ora andiamo alla pagina web del repository forked https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo e facciamo clic su Settings.
Poi, nel riquadro a sinistra, trova Secrets and variables, fai clic e seleziona Actions.
Dopodiché, fai clic su New repository secret per configurare il secret GEMINI_API_KEY.
Dopodiché, seleziona Pull Request e crea una nuova richiesta di pull dal ramo feature/bulk_operations al ramo main del tuo repository.
Una volta creata la richiesta di pull, verranno eseguite le azioni di GitHub, che puoi controllare nel menu Checks o vicino al pulsante Merge pull request.
Puoi fare clic sulle azioni in esecuzione per visualizzare i dettagli e, al termine, i risultati della revisione verranno pubblicati come commento alla richiesta di pull, come mostrato di seguito.
8. Conclusione
Complimenti!
Hai creato due workflow completi di revisione del codice per rilevare le vulnerabilità di sicurezza nelle funzionalità con codice di vibrazione:
- Caso 1 (interattivo): l'interfaccia a riga di comando Antigravity con le competenze dell'agente ha esaminato una differenza tra rami di funzionalità, ha identificato l'SQL injection e altre vulnerabilità, le ha corrette seguendo i pattern OWASP e ha prodotto una richiesta di pull pulita.
- Scenario 2 (automatizzato): l'SDK Antigravity ha alimentato un'azione di GitHub che esamina automaticamente ogni richiesta di pull, pubblicando i risultati strutturati relativi alla sicurezza come commenti alle richieste di pull.
Che cosa hai imparato
- In che modo il vibe coding crea rischi per la sicurezza e perché la revisione automatizzata rileva ciò che la revisione manuale non rileva
- Come installare e utilizzare le competenze dell'agente per fornire all'interfaccia a riga di comando Antigravity competenze di sicurezza strutturate
- Come esaminare in modo interattivo la differenza di un ramo di funzionalità, risolvere i problemi e creare una richiesta di pull pulita
- Come creare un agente di revisione di sola lettura con l'SDK Antigravity utilizzando criteri di negazione predefinita e hook del ciclo di vita
- Come eseguire il deployment di una pipeline di revisione automatizzata come azione GitHub con supporto interattivo di follow-up
Pulizia
Chiudi le PR
Vai a ogni richiesta di pull nel fork su GitHub e fai clic su Chiudi richiesta di pull. Non unire la richiesta pull feature/bulk-operations, in quanto contiene ancora il codice vulnerabile non corretto.
(Facoltativo) Elimina il repository di cui è stato eseguito il fork
Se non hai più bisogno del fork, vai al tuo fork su GitHub: Settings (Impostazioni) -> scorri fino a Danger Zone (Zona di pericolo) -> Delete this repository (Elimina questo repository).
Passaggi successivi
- Plug-in e skill di Antigravity CLI: crea plug-in e skill personalizzati
- Autorizzazioni e sandbox di Antigravity CLI: criteri granulari per gli strumenti e sandbox a livello di sistema operativo
- Hook e norme dell'SDK Antigravity: pattern avanzati (limitazione della frequenza, recupero degli errori, middleware)
- Esempi di Antigravity SDK:
agent_middleware.pyper pattern di produzione