1. Einführung
Beim Vibe Coding – dem Schreiben von Code durch KI-Agents auf Grundlage von Prompts in natürlicher Sprache – verschiebt sich die Rolle des Entwicklers vom Autor zum Orchestrator und Prüfer. Wir verlassen uns darauf, dass wir den perfekten Kontext vorbereiten, und vertrauen darauf, dass die KI-Agents alles für uns erledigen, von der Erstellung der Spezifikationsdokumente bis hin zur Sicherstellung, dass der Code alle Anforderungen erfüllt. Das Risiko: In schnellen Iterationszyklen wird funktionaler Code ohne gründliche Sicherheitsüberprüfung genehmigt. Moderne Agents generieren oft standardmäßig sicheren Code, aber „oft“ ist nicht „immer“. Außerdem können sich bei der manuellen Überprüfung angesammelte Sicherheitslücken einschleichen.
In diesem Codelab werden diese Probleme behandelt, indem zwei Ansätze für die Verwendung von Antigravity als Prüfer vorgestellt werden: interaktiv während der Entwicklung mit der CLI (Sie überprüfen, beheben und dann PR) und automatisch in der Continuous Integration mit dem SDK (der Agent überprüft jede Pull-Anfrage und postet die Ergebnisse als Kommentar).
Themen
Sie haben eine Leads-CRM-App mit Vibe-Code erstellt. Ein KI-Agent hat den gesamten Stack für Sie erstellt: Express-Backend, SQLite-Datenbank, React-Frontend. Es funktioniert. Anschließend haben Sie den Agent gebeten, zwei neue Funktionen hinzuzufügen: eine Funktion zur Lead-Suche und einen Bulk-Import/-Export mit Administratorstatistiken. Der Kundenservicemitarbeiter hat beides schnell erledigt. Der Code wird ausgeführt, die Funktionen funktionieren und die PRs sind bereit.
Das Problem ist jedoch, dass Sie diesen Code nicht selbst geschrieben haben. Sie haben sie genehmigt. Woher wissen Sie, dass der Such-Endpunkt nicht anfällig für SQL-Injection ist? Woher wissen Sie, dass die Administratorroute kein hartcodiertes Passwort hat? Nein. Wenn Sie jede Zeile des KI-generierten Codes lesen, geht der Geschwindigkeitsvorteil verloren, der Sie überhaupt erst zum Vibe-Coding veranlasst hat.
In diesem Codelab werden zwei Möglichkeiten zur Lösung dieses Problems vorgestellt:
- Fall 1: Interaktive Überprüfung: Sie sehen sich einen Feature-Branch mit Sicherheitslücken an, verwenden die Antigravity CLI mit Agent-Skills, um den Diff zu prüfen, beheben die Probleme und erstellen einen sauberen Pull-Request.
- Fall 2: Automatisierte Überprüfung: Richten Sie eine GitHub-Aktion ein, die auf dem Antigravity SDK basiert und Pull-Anfragen automatisch überprüft, strukturierte Ergebnisse als Kommentare postet und antwortet, wenn Entwickler Nachfragen zur Überprüfung stellen.
Lerninhalte
- Wie Vibe-Coding Sicherheitsrisiken birgt und warum bei der automatisierten Überprüfung Dinge erkannt werden, die bei der manuellen Überprüfung übersehen werden
- Von der Community verwaltete Agent-Fähigkeiten installieren und verwenden, um der Antigravity CLI umfassende Sicherheits- und Code-Review-Expertise zu verleihen
- Interaktive Verwendung der Befehlszeile zum Prüfen eines Feature-Branch-Diffs, Beheben von Sicherheitslücken und Erstellen eines sauberen PR
- So erstellen Sie mit dem Antigravity SDK einen schreibgeschützten Code-Review-Agenten mit deklarativen Sicherheitsrichtlinien und Lebenszyklus-Hooks
- So stellen Sie den Review-Agent als GitHub-Aktion bereit, die Pull-Anfragen prüft und das Ergebnis als Pull-Anfrage-Kommentar postet
Voraussetzungen
- Ein Google Cloud-Konto
- Ein GitHub-Konto
- Grundkenntnisse zu Terminal, Versionsverwaltung und CI/CD
2. Umgebung einrichten
In diesem Schritt wird das Repository der Leads CRM-App geforkt, in Cloud Shell geklont, die Antigravity-Befehlszeile eingerichtet und die Authentifizierung durchgeführt.
Repository verzweigen
Sie benötigen eine eigene Kopie des Repositorys, da Sie Commits pushen und Pull-Anfragen mit GitHub Actions erstellen.
Rufen Sie das folgende Repository auf
Klicken Sie dann auf Fork. Entfernen Sie auf der Seite zum Erstellen des Forks das Häkchen bei „Nur den main-Branch kopieren“. Sie benötigen die anderen Feature-Branches (feature/lead-search und feature/bulk-operations) in Ihrem Fork.
Cloud Shell öffnen
Öffnen Sie Cloud Shell in Ihrem Browser. Cloud Shell bietet eine vorkonfigurierte Umgebung mit allen Tools, die Sie für dieses Codelab benötigen. Klicken Sie auf Autorisieren, wenn Sie dazu aufgefordert werden.
Klicken Sie dann auf Ansicht -> Terminal, um das Terminal zu öffnen.Die Benutzeroberfläche sollte so aussehen:
Das ist unsere Hauptschnittstelle: oben die IDE, unten das Terminal.
Mit GitHub authentifizieren
In Cloud Shell sind standardmäßig keine GitHub-Anmeldedaten konfiguriert, aber die gh-Befehlszeile ist bereits installiert. Richten Sie die Authentifizierung ein, damit Sie später Commits pushen und Pull-Requests erstellen können:
gh auth login
„Github.com“ auswählen
Wählen Sie HTTPS aus ( oder einen anderen Mechanismus, wenn Sie damit vertraut sind).
Wählen Sie dann Y aus.
Wählen Sie dann Login with a web browser aus.
**,**Sie werden aufgefordert, den Einmalcode zu kopieren und einzugeben, wenn Sie die Anmeldeseite im Browser öffnen. Sie können Ctrl + Click auf die URL im Terminal klicken, um die URL https://github.com/login/device zu öffnen. Sie werden aufgefordert, das Konto auszuwählen, mit dem Sie sich anmelden möchten, und den Code einzugeben.
Kehren Sie dann zur Cloud Shell-Konsolenseite zurück. Dort sehen Sie die Terminalausgabe wie unten dargestellt.
✓ 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
Das bedeutet, dass Sie die Authentifizierung Ihres GitHub-Kontos in Cloud Shell eingerichtet haben.
Verzweigtes Repository klonen
Als Nächstes klonen wir das verzweigte Repository. Ersetzen Sie <YOUR_GITHUB_USERNAME> durch Ihren GitHub-Nutzernamen.
git clone https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo.git
cloudshell workspace leads-crm-app-demo && cd leads-crm-app-demo
Feature-Branches bestätigen
Prüfen Sie dann, ob beide Feature-Branches mit integrierten Sicherheitslücken im Remote-Repository verfügbar sind:
git branch -a | grep feature/
Es sollte folgende Ausgabe angezeigt werden:
remotes/origin/feature/bulk-operations remotes/origin/feature/bulk-operations-solution remotes/origin/feature/email-composer remotes/origin/feature/lead-search
Antigravity CLI überprüfen
Prüfen wir als Nächstes, ob die Antigravity CLI in Cloud Shell vorinstalliert ist. So prüfen Sie, ob die Funktion verfügbar ist:
agy --version
Die Version des installierten Antigravity CLI sollte angezeigt werden, z. B. 1.0.13.
Wenn Sie die Antigravity CLI noch nicht authentifiziert haben, können Sie sich in diesem Codelab den Authentifizierungsprozess genauer ansehen.
Sie sollten jetzt Folgendes haben:
- Das verzweigte Repository wurde geklont.
- Beide Feature-Branches sind sichtbar.
- Der Befehl
agyist verfügbar und authentifiziert.
3. Das Problem: Schwachstellen in Funktionen mit Vibe-Codierung
Ein Kollege hat einen KI-Agenten verwendet, um der Leads-CRM-App zwei Funktionen hinzuzufügen: eine Lead-Suchfunktion und Bulk-Import-/Exportvorgänge. Beide Funktionen funktionieren. Beide wurden schnell ohne Sicherheitsüberprüfung versendet. Sie werden beide Zweige vor dem Zusammenführen prüfen – einen interaktiv mit der CLI und einen automatisch mit einer GitHub Action.
Ersten Feature-Branch untersuchen
Sehen Sie sich die Unterschiede in feature/lead-search an:
git diff main...origin/feature/lead-search
In diesem Branch wird ein Such-Endpunkt hinzugefügt. Sehen Sie sich den Diff an. Sie sollten Probleme wie die Verkettung von Strings in SQL-Abfragen, fehlende Eingabevalidierung, Debug-Logging, bei dem Abfragedetails preisgegeben werden, und Rohfehlermeldungen, die dem Client angezeigt werden, erkennen.
+ 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" });
+ }
...
Zweiten Feature-Branch untersuchen
git diff main...origin/feature/bulk-operations
In diesem Branch werden Endpunkte für den Massenimport/-export und ein Dashboard mit Administratorstatistiken hinzugefügt. Zu den Schwachstellen gehören fest codierte Administratoranmeldedaten, nicht authentifizierte Administrator-Endpunkte, keine Eingabevalidierung beim Massenimport und das Risiko von Path Traversal bei der Verarbeitung von Exportdateinamen.
...
+ 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" });
+ }
...
In beiden Zweigen werden funktionale Funktionen hinzugefügt. Beide haben Sicherheitsprobleme. Die Frage ist, wie Sie sie abfangen – manuell mit der CLI (Fall 1) oder automatisch mit einer GitHub Action (Fall 2).
4. Fall 1 : Interaktive Überprüfung mit der Antigravity CLI
Die interaktive CLI-Überprüfung ist am nützlichsten direkt nach einer Vibe-Coding-Sitzung, wenn Sie den gerade geschriebenen Code oder die Pull-Anfrage Ihres Teams überprüfen. Wenn wir über Vibe-Coding sprechen, hat ein KI-Agent Ihren Funktionscode schnell generiert. Sie verstehen aber möglicherweise nicht jede Zeile, die er erstellt hat, und der Agent ist je nach Kontextkonfiguration während der Entwicklung der Funktion möglicherweise für die Funktionalität und nicht unbedingt für die Sicherheit optimiert.
In diesem Szenario haben wir diese Codes mit Sicherheitslücken und verwenden die Antigravity CLI mit Code-Review-Funktionen, um den Code interaktiv zu prüfen. Dieses Muster fängt Sicherheitslücken ab, die entstehen, wenn die Rolle des Entwicklers sich vom Schreiben von Code zum Genehmigen von KI-generiertem Code verschiebt. Das gilt auch, wenn Sie Ihren eigenen manuell geschriebenen Code oder den Branch eines Teammitglieds überprüfen, bevor er durch CI läuft. Sie haben die Kontrolle über die Konversation: Bitten Sie den Agent, sich auf bestimmte Dateien zu konzentrieren, ein Ergebnis genauer zu untersuchen oder Korrekturen sofort anzuwenden.
Auch ohne Agent-Skills kann Antigravity CLI Code prüfen. Dabei wird jedoch auf das allgemeine Trainingswissen zurückgegriffen, sodass domänenspezifische Muster möglicherweise nicht erkannt oder inkonsistente Prüfkriterien für verschiedene Sitzungen angewendet werden. Agent-Fähigkeiten bieten dem Agent ein strukturiertes Playbook: Fünf-Achsen-Überprüfung für die Qualität, Schweregradkennzeichnung für die Priorisierung. Die Überprüfung wird wiederholbar und gründlich, unabhängig davon, wie Sie Ihren Prompt formulieren.
In diesem Schritt wird die Antigravity-Befehlszeile mit Agent-Skills verwendet, um den feature/lead-search-Branch zu prüfen, die Sicherheitslücken zu beheben und einen sauberen PR zu erstellen.
Funktionszweig auschecken
Als Erstes wechseln wir zum Zweig für Fall 1:
git checkout feature/lead-search
Als Nächstes aktualisieren wir unsere Antigravity CLI mit den Agent-Skills für die Überprüfung.
Was sind Agent Skills?
Skills sind deklarative Markdown-Dateien, die dem Agenten spezielles Fachwissen vermitteln. Nach der Installation werden sie zu Slash-Befehlen (z.B. /code-review-and-quality). Sie können sich das so vorstellen, dass ein Agent für allgemeine Zwecke das Sicherheits-Playbook eines Senior Engineers erhält.
Skills sind über verschiedene Agenten (Antigravity, Claude Code, Cursor usw.) hinweg übertragbar und können über Git geteilt werden. Für die Antigravity CLI befinden sich Workspace-Skills (Projekt/lokal) im Projektstammverzeichnis unter .agents/skills/. Globale Skills befinden sich in ~/.gemini/config/skills/. Weitere Informationen
In diesem Codelab wird der Skill für die Codeüberprüfung aus addyosmani/agent-skills verwendet, um die Funktionen von Agent-Skills zu demonstrieren:
code-review-and-quality– Fünfachsige Überprüfung (Richtigkeit, Lesbarkeit, Architektur, Sicherheit, Leistung) mit Schweregradkennzeichnung.
Code Review-Agenten-Skill installieren
Mit dem folgenden Befehl wird der Skill standardmäßig im aktuellen Arbeitsverzeichnis installiert, also auf Arbeitsbereichsebene..agents/skills/ Das bedeutet, dass sie Teil des Repositorys werden und zusammen mit Ihrem Code committet werden können. So erhält jeder Entwickler (und jede CI-Pipeline) im Projekt automatisch dieselben Überprüfungsfunktionen.
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
So sieht die detaillierte Skill aus, die in der Datei .agents/skills/code-review-and-quality/SKILL.md geprüft werden kann:
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.
Hauptfunktionen:
- Überprüfungen in fünf Bereichen: Richtigkeit, Lesbarkeit, Architektur, Sicherheit und Leistung
- Ergebnisse werden nach Schweregrad gekennzeichnet, damit Sie kritische Probleme zuerst beheben können
- Wendet den Genehmigungsstandard „Genehmigen, wenn der Code insgesamt definitiv verbessert wird, auch wenn er nicht perfekt ist“ an.
Jetzt können wir mit der Ausführung beginnen. Skill in der Antigravity CLI überprüfen
AGY starten und Fähigkeiten bestätigen
Antigravity CLI ausführen
agy --dangerously-skip-permissions
Führen Sie dann den folgenden Befehl aus:
/skills
Die beiden Skills sollten unter Workspace-Skills so angezeigt werden:
Code-Review der Funktionsunterschiede durchführen
Rufen Sie den Sicherheits-Skill auf und bitten Sie ihn, Ihren Branch zu überprüfen. Geben Sie diesen Prompt ein:
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.
Der Agent erkennt den relevanten code-review-and-quality-Skill und aktiviert ihn automatisch. Es liest den Diff, identifiziert Sicherheitslücken und schreibt die Ergebnisse mit einem vorgeschlagenen Korrekturplan in code_review.md.
Nach dem Scannen sollte in Ihrem Arbeitsverzeichnis die Datei code_review.md erstellt worden sein. Sie können sie im Editor ansehen.
Sehen Sie sich die einzelnen Ergebnisse und die vorgeschlagene Korrektur an. Wenn Sie mit dem Plan zufrieden sind, bitten Sie den Agenten, ihn anzuwenden:
Apply the proposed fixes from code_review.md
Der Agent liest den Plan und wendet jede geplante Korrektur auf die Quelldateien an.
Jetzt können Sie prüfen, ob die App nach der Korrektur richtig ausgeführt wird. Installieren Sie dazu die Abhängigkeiten und führen Sie die App aus.
npm install
npm run dev
Die Anwendung sollte ordnungsgemäß ausgeführt werden. Falls nicht, können Sie das Problem beheben lassen.
Commit ausführen und Pull-Anfrage erstellen
Jetzt können Sie die Änderungen per Push in Ihr eigenes Repository übertragen, wenn Sie möchten. Bevor wir zum nächsten Fall übergehen, committen wir die Änderungen zuerst im aktuellen Branch.
Zuerst müssen Sie Ihre Git-Identität konfigurieren (ersetzen Sie die Platzhalter durch Ihren eigenen Namen und Ihre eigene E-Mail-Adresse), falls Sie das noch nicht getan haben:
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
Änderungen übernehmen
git add .
git commit -m "fix: address security vulnerabilities in lead search feature"
Sie haben die Antigravity CLI bereits als interaktiven Prüfer verwendet. Die Skills boten eine strukturierte Methodik – die fünfachsige Codeüberprüfung. Das funktioniert, wenn Sie der Entwickler sind, der den KI-generierten Code überprüft, unabhängig davon, ob es sich um Ihren eigenen Beitrag oder den eines Teammitglieds handelt. Im nächsten Abschnitt automatisieren wir diesen gesamten Ablauf, um ihn als skalierbaren automatisierten Prozess in Ihrem Code-Repository zu implementieren. Wir verwenden dazu GitHub als Beispiel.
5. Fall 2 : Automatisierte Überprüfung mit dem Antigravity SDK – Teil 1 ( Agent erstellen)
In diesem Schritt wird ein automatisierter Überprüfungs-Agent mit dem Antigravity SDK erstellt, als GitHub-Aktion bereitgestellt und anhand des zweiten Feature-Branch getestet. Der Agent überprüft Pull-Anfragen auf Anfrage und postet die Ergebnisse als PR-Kommentare.
Warum automatisierte Überprüfung?
Die interaktive CLI-Überprüfung (Fall 1) funktioniert, wenn ein Entwickler aktiv prüft. Teams benötigen eine Überprüfung, die automatisch bei jedem PR ausgeführt wird, um Probleme von jedem Mitwirkenden, jedem Tool und zu jeder Zeit zu erkennen. Das Antigravity SDK (google-antigravity) bietet dieselbe Agent-Laufzeit wie die CLI, jedoch als Python-Bibliothek. Richtlinien und Hooks werden im Code konfiguriert.
GitHub Actions ist die integrierte CI/CD-Plattform (Continuous Integration/Continuous Development) von GitHub. Es führt Workflows aus – automatisierte Skripts, die in YAML definiert sind – als Reaktion auf Repository-Ereignisse wie das Öffnen einer Pull-Anfrage, das Pushen eines Commits oder das Posten eines Kommentars. Workflows werden auf von GitHub gehosteten virtuellen Maschinen ausgeführt und haben Zugriff auf den Repository-Code. In diesem Fall verwenden Sie eine GitHub-Aktion, um jedes Mal, wenn eine Pull-Anfrage erstellt wird, einen Sicherheitsüberprüfungs-Agent auszuführen.
So funktioniert der automatisierte Überprüfungsprozess:
Das Antigravity SDK ( google-antigravity) bietet dieselbe Agent-Laufzeit wie die CLI, jedoch als Python-Bibliothek. Sie schreiben ein Python-Skript, das den Agenten mit Richtlinien und Hooks konfiguriert, führen es in einer GitHub-Aktion aus und posten die Ergebnisse als PR-Kommentar.
Gemini API-Schlüssel anfordern
Bevor wir beginnen, benötigen wir den Gemini API-Schlüssel, der vom Antigravity SDK verwendet wird. Rufen Sie Google AI Studio-API-Schlüssel auf und erstellen Sie einen API-Schlüssel. Sie können ihn bei Bedarf kopieren.
Dieser Schlüssel wird verwendet, wenn der Review-Agent lokal ausgeführt wird, und später als GitHub Actions-Secret.
Teil A: Rezensions-Agenten erstellen
Wechseln Sie nun für Fall 2 in das Arbeitsverzeichnis des feature/bulk-operations-Zweigs:
git checkout feature/bulk-operations
Dies ist der zweite Feature-Branch aus dem Szenario. Er fügt der CRM-App Bulk-Import-/Export-Endpunkte und ein Admin-Statistik-Dashboard hinzu.
Python-Projekt einrichten
Das Antigravity SDK ist derzeit nur in Python verfügbar. Daher benötigen wir eine Python-Umgebung, um es zu entwickeln. Wir verwenden uv für unseren Python-Projektmanager. uv ist ein schneller Python-Paket- und Projektmanager, der in Rust geschrieben wurde ( Dokumentation). In diesem Codelab wird sie aus Gründen der Geschwindigkeit und Einfachheit verwendet. Wenn Sie Cloud Shell für diese Anleitung verwenden, ist es bereits auf der Instanz vorinstalliert. In dieser Anleitung erfahren Sie, wie Sie die Erweiterung lokal installieren.
Initialisieren Sie ein Python-Projekt für den Rezensions-Agenten mit uv:
uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7
Dadurch wird ein neues Verzeichnis code_review_agent erstellt, das die erforderlichen Dateien für den Code-Review-Agent enthält.
Skills für Rezensionen installieren
Der Prüf-Agent benötigt dieselben Sicherheits- und Code-Prüfungskompetenzen wie in Fall 1. Installieren Sie sie in code_review_agent/skills/, damit der SDK-Agent sie zur Laufzeit lädt:
npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills
KI-Agenten für Rezensionen erstellen
Erstellen wir nun code_review_agent/review_agent.py . Führen Sie den folgenden Befehl aus:
cloudshell edit code_review_agent/review_agent.py
Kopieren Sie dann den folgenden Inhalt in die Datei.
#!/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))
Sehen Sie sich die wichtigsten Designentscheidungen in diesem Agenten an:
- Standardmäßig ablehnen-Richtlinien:
policy.deny_all()blockiert alles und lässt dann speziell nur Tools zum Lesen von Dateien undrun_command(für Git) zu. - Erzwingung auf zwei Ebenen: Richtlinien schränken auf Framework-Ebene ein und der
enforce_safe_tools-Hook bietet eine zweite Ebene, die nurgit-Befehle überrun_commandzulässt . - Git-Diff-Bereich: Der Agent führt
git diff main...HEADaus, um nur geänderten Code und nicht die gesamte Codebasis zu überprüfen. - Strukturierte Ausgabe mit Fallback:
response_schema=ReviewResulterzwingt die JSON-Struktur über das SDK-Tool „finish“. Wenn das Parsen fehlschlägt, versucht die Fallback-Kette,text()als JSON zu parsen. Andernfalls wird Rohtext zurückgegeben. - Auth-Fallback: Verwendet
GEMINI_API_KEY, falls verfügbar, andernfalls wird über Standardanmeldedaten für Anwendungen auf Vertex AI zurückgegriffen. - Dateiausgabe: Schreibt formatierte Markdown-Ergebnisse in
code_review.md. Die GitHub-Aktion liest diese Datei und postet sie später als PR-Kommentar.
Überprüfungs-Agenten testen
Tests über das Projektstammverzeichnis ausführen Das SDK liest GEMINI_API_KEY aus der Umgebung. Wir legen den Schlüssel also in der Umgebung ab.
export GEMINI_API_KEY=YOUR_API_KEY
Führen Sie dann den folgenden Befehl aus, um ihn lokal auszuführen:
uv run --project code_review_agent code_review_agent/review_agent.py .
Während der Ausführung wird in der Konsole ausgegeben, welche Tools gerade verwendet werden. Sie können sehen, dass auf die Agent-Skills security-and-hardening und code-review-and-quality zugegriffen wird.
[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'] ...
Der Agent führt git diff main...HEAD aus, prüft nur den geänderten Code, schreibt formatierte Ergebnisse in code_review.md und gibt strukturiertes JSON in der Konsole aus. Sie können die erstellte code_review.md im Editor wie unten dargestellt überprüfen.
Lokal funktioniert es bereits. Fahren wir mit dem nächsten Teil fort. GitHub Action-Konfiguration erstellen
6. Fall 2 : Automatisierte Überprüfung mit dem Antigravity SDK – Teil 2 ( Konfigurieren von GitHub Actions)
Bevor wir beginnen, löschen wir die zuvor erstellte code_review.md-Datei, falls sie vorhanden ist.
rm -f code_review.md
Als Nächstes müssen wir die YAML-Konfigurationsdatei für die GitHub-Aktion erstellen.
mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml
Fügen Sie der Datei dann den folgenden Inhalt hinzu.
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
});
Der Workflow wird automatisch ausgelöst, wenn ein Pull-Request geöffnet oder aktualisiert wird. Dabei wird der PR-Branch mit dem vollständigen Git-Verlauf ausgecheckt (erforderlich für git diff main...HEAD), der Review-Agent wird ausgeführt, der die Ergebnisse in code_review.md schreibt, und der Dateiinhalt wird als PR-Kommentar gepostet.
Übertragen wir nun alle Änderungen und übertragen wir sie an das GitHub-Remote. Wir sind bereit, diese Integration zu testen.
git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations
7. Fall 2 : Automatisierte Überprüfung mit dem Antigravity SDK – Teil 3 (Automatisierte Code-Überprüfung testen)
Rufen Sie nun die Webseite Ihres geforkten Repositorys https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo auf und klicken Sie auf Settings.
Suchen Sie dann im linken Bereich nach Secrets and variables und klicken Sie darauf, um Actions auszuwählen.
Klicken Sie dann auf das New repository secret, um das GEMINI_API_KEY-Secret zu konfigurieren.
Wählen Sie dann Pull Request aus und erstellen Sie eine neue Pull-Anfrage vom Branch feature/bulk_operations zum Branch main Ihres eigenen Repositorys.
Nachdem die Pull-Anfrage erstellt wurde, werden die GitHub-Aktionen ausgeführt, die Sie im Menü Checks oder in der Nähe der Schaltfläche Merge pull request aufrufen können.
Sie können auf die laufenden Aktionen klicken, um die Details zu sehen. Wenn die Aktionen abgeschlossen sind, werden die Überprüfungsergebnisse als Pull-Request-Kommentar gepostet, wie unten dargestellt.
8. Zusammenfassung
Das wars!
Sie haben zwei vollständige Code-Review-Workflows erstellt, um Sicherheitslücken in Vibe-codierten Funktionen zu erkennen:
- Fall 1 (interaktiv): Die Antigravity CLI mit Agent-Skills hat einen Diff für einen Feature-Branch überprüft, SQL-Injection- und andere Sicherheitslücken erkannt, sie gemäß OWASP-Mustern behoben und einen sauberen PR erstellt.
- Fall 2 (automatisiert): Das Antigravity SDK hat eine GitHub-Aktion unterstützt, die jede Pull-Anfrage automatisch überprüft und strukturierte Sicherheitsergebnisse als Pull-Anfrage-Kommentare postet.
Das haben Sie gelernt
- Wie Vibe-Coding Sicherheitsrisiken birgt und warum bei der automatisierten Überprüfung Dinge erkannt werden, die bei der manuellen Überprüfung übersehen werden
- Agent-Skills installieren und verwenden, um der Antigravity CLI strukturiertes Sicherheits-Know-how zu vermitteln
- Interaktives Überprüfen von Unterschieden in einem Feature-Branch, Beheben von Problemen und Erstellen eines sauberen Pull-Requests
- Einen schreibgeschützten Rezensionsagenten mit dem Antigravity SDK erstellen, indem Sie Standardrichtlinien und Lebenszyklus-Hooks verwenden
- Anleitung: Eine automatisierte Überprüfungspipeline als GitHub-Aktion mit interaktivem Follow-up-Support bereitstellen
Aufräumen
Pull-Requests schließen
Rufen Sie jede Pull-Anfrage in Ihrem Fork auf GitHub auf und klicken Sie auf Close pull request (Pull-Anfrage schließen). Führen Sie den feature/bulk-operations-PR nicht zusammen, da er weiterhin den ungepatchten anfälligen Code enthält.
Geforktes Repository löschen (optional)
Wenn Sie den Fork nicht mehr benötigen, rufen Sie ihn auf GitHub auf: Settings (Einstellungen) -> scrollen Sie zu Danger Zone (Gefahrenzone) -> Delete this repository (Dieses Repository löschen).
Nächste Schritte
- Antigravity CLI-Plug-ins und ‑Skills: Erstellen Sie benutzerdefinierte Skills und Plug-ins.
- Antigravity-CLI-Berechtigungen und Sandbox – detaillierte Tool-Richtlinien und Sandboxing auf Betriebssystemebene
- Antigravity SDK-Hooks und ‑Richtlinien – erweiterte Muster (Ratenbegrenzung, Fehlerbehebung, Middleware)
- Antigravity SDK – Beispiele –
agent_middleware.pyfür Produktionsmuster