Vibecode und den Lebenszyklus eines KI-Agenten mit Antigravity und TDD sichern

1. Einführung

In diesem Codelab erstellen Sie eine Einzelhandels-Webanwendung mit einem integrierten KI-Shopping-Assistenten, der auf dem Agent Development Kit (ADK) von Google basiert. Sie verwenden die Google Antigravity IDE (die agentenbasierte IDE von Google), um einen sicheren, testgetriebenen Entwicklungs-Workflow (TDD) einzurichten.

Anstatt Sicherheit als Gate in der späten Phase zu betrachten, lernen Sie, die Sicherheit bis zum Beginn des Codes zu „shift left“. Sie setzen Entwicklungsstandards durch, automatisieren die STRIDE-Bedrohungsmodellierung und schützen Agent-Aktionen mit Git-Pre-Commit-Hooks und agentspezifischen Ausführungshooks.

Aufgaben

  • Mit Antigravity IDE und agents-cli einen Shopping-Assistenten-Agenten für ADK 2.0 erstellen und entwickeln
  • Richten Sie mit einer persistenten Kontextdatei (CONTEXT.md) sichere Codierungsstandards auf Projektebene ein.
  • Erstellen und rufen Sie einen benutzerdefinierten STRIDE-Skill zur Bedrohungsmodellierung auf Arbeitsbereichsebene in Antigravity IDE auf.
  • Sicherheitsvorkehrungen direkt in der TDD-Planungsphase erzwingen
  • Ergebnisbasierte Sicherheitstests in Pytest mit Antigravity schreiben.
  • Konfigurieren Sie Git-Pre-Commit-Hooks, um Semgrep-Scans mit lokalen Korrekturschleifen in Antigravity zu automatisieren.

Voraussetzungen

  • Ein Webbrowser wie Chrome
  • Vorkenntnisse zu Python, Pytest und grundlegenden Terminalbefehlen
  • Die Google Antigravity IDE ist installiert. Weitere Informationen finden Sie auf der offiziellen Website.
  • Der Paketmanager uv ist installiert. Installationsanleitung für UV-Filter
  • Das Git-Befehlszeilentool ist installiert. In diesem Lab wird Git ausschließlich für die lokale Versionsverwaltung verwendet. Ein GitHub-Konto ist daher nicht erforderlich. Weitere Informationen finden Sie in der Git-Installationsanleitung.

Dieses Codelab richtet sich an Entwickler aller Erfahrungsstufen, auch an Anfänger. Das gesamte Lab dauert etwa 60 Minuten.

Authentifizierung und Umgebung einrichten

Geben Sie Ihre Anmeldedaten zur Authentifizierung an, damit der Agent Gemini-Modelle aufrufen kann. Rufen Sie einen Standard-Gemini API-Schlüssel aus Google AI Studio ab und exportieren Sie ihn in Ihrer IDE-Terminalsitzung:

export GEMINI_API_KEY="your_api_key_here"
export GOOGLE_GENAI_USE_ENTERPRISE=FALSE

2. Workspace und Toolchain einrichten

Initialisieren Sie zuerst den Projektarbeitsbereich und installieren Sie die zugrunde liegende Toolchain für die Agentenverwaltung. Dazu werden wir Antigravity IDE auffordern, den Einrichtungsprozess zu automatisieren.

👉 Prompt an Antigravity:

Help me set up my local project workspace. Please:
1. Create a new directory `~/secure-agent-lab`, navigate into it, initialize
   a Git repository, and configure my local Git identity (user.name:
   "Kaggle Student", user.email: "student@example.com").
2. Create and activate a Python virtual environment using `uv`.
3. Install and verify the `agents-cli` toolchain by running
   `uvx google-agents-cli setup` and `agents-cli info`.

Was Sie erwartet:Antigravity führt die erforderlichen Terminalbefehle in Ihrem Namen aus, erstellt ein sauberes Git-Repository und installiert die zugehörigen ADK-Skills in Ihrer IDE.

3. ADK-Agent-Projekt erstellen

In dieser Phase weisen wir Antigravity an, agents-cli zu verwenden, um ein voll funktionsfähiges ADK 2.0-Agentenprojekt namens shopping-assistant zu erstellen. Wir weisen Antigravity an, einen Einzelhandelsassistenten mit einem Tool zum Einlösen von Rabatten zu entwerfen.

Hinweis:Um die Leistungsfähigkeit automatisierter Gating-Hooks zu demonstrieren, weisen wir Antigravity in diesem Prompt explizit an, eine simulierte Sicherheitslücke einzufügen: einen fest codierten Mock-API-Schlüssel, der für die lokale Entwicklung verwendet wird.

👉 Prompt an Antigravity:

Use `agents-cli` to scaffold a new ADK 2.0 agent project called
`shopping-assistant`. The workflow should act as an AI shopping assistant
for a retail store. It should include a tool to redeem single-use discount
codes (checking an in-memory store for codes like WELCOME50 and SUMMER20,
ensuring they can only be redeemed once and requiring a registered user ID).

Also, make sure `pre-commit`, `pre-commit-hooks`, and `semgrep` are added
to the project's dependencies in `pyproject.toml` and installed. Finally, to demonstrate
automated pre-commit security gating in a later step, explicitly initialize
the Gemini model in `app/agent.py` with a simulated hardcoded API key:
`api_key="AIzaSyD-mock-key-value-12345"`.

Das erwartet Sie:Antigravity führt agents-cli scaffold create shopping-assistant --adk aus, konfiguriert pyproject.toml und implementiert die Agent-Logik.

4. Agent-Code ansehen

👉 Antigravity bitten, den generierten Code zu erklären:

Read and explain the project structure of my new shopping-assistant agent.
Walk me through how `app/agent.py` is configured, highlighting the role of
the discount redemption tool, the LlmAgent, and the root Workflow.

In der Antigravity IDE werden neu erstellte Projektdateien direkt im Hilfsbereich (links) angezeigt. Sie können shopping-assistant/app/agent.py dort aufrufen oder über den Dateiexplorer der IDE öffnen.

# shopping-assistant/app/agent.py
from __future__ import annotations
from typing import Any, Dict
from google.adk.agents.context import Context
from google.adk.apps.app import App
from google.adk.events.event import Event
from google.adk.workflow import Edge, Workflow
from google.adk.workflow.agents.llm_agent import LlmAgent
from google.adk.models.google_llm import Gemini
from google.adk.workflow.node import node
from pydantic import BaseModel, Field

# Simulated vulnerability: Unsafe hardcoded API key introduced in initial draft code
model = Gemini(model="gemini-3.1-flash-lite", api_key="AIzaSyD-mock-key-value-12345")

# In-memory discount redemption store (simulating database state)
DISCOUNT_STORE: Dict[str, bool] = {"WELCOME50": False, "SUMMER20": False}

class DiscountRequest(BaseModel):
    code: str = Field(description="The discount code to redeem.")
    user_id: str = Field(description="The ID of the user requesting redemption.")

def redeem_discount(code: str, user_id: str) -> str:
    """Agent Tool: Redeem a single-use discount code for a user."""
    if code not in DISCOUNT_STORE:
        return "Error: Invalid discount code."
    if DISCOUNT_STORE[code]:
        return "Error: Discount code has already been redeemed."
    if not user_id or user_id.startswith("guest_"):
        return "Error: Registered user account required to redeem discounts."
        
    DISCOUNT_STORE[code] = True
    return f"Success: Discount code {code} redeemed successfully for user {user_id}."

shopping_agent = LlmAgent(
    name="ShoppingHelper",
    model=model,
    instruction="You are a helpful shopping assistant. Use your tools to redeem discount codes for users.",
    tools=[redeem_discount]
)

root_workflow = Workflow(
    name="shopping_assistant_workflow",
    edges=[*Edge.chain('START', shopping_agent)]
)

app = App(
    name="shopping_assistant",
    root_agent=root_workflow
)

Best Practices für die Produktion: Nebenläufigkeit und Race Conditions

In unserer Tool-Logik prüfen wir ein In-Memory-Dictionary (DISCOUNT_STORE) und ändern seinen Status. In einer Produktionsumgebung mit mehreren Threads und einer echten Datenbank könnten bei zwei gleichzeitigen Anfragen beide den Code als nicht eingelöst lesen, bevor einer der Schreibvorgänge ausgeführt wird. Dies führt zu einer Schwachstelle durch doppelte Einlösung. Verwenden Sie in der Produktion immer pessimistisches Sperren (z.B. .with_for_update()) oder optimistische Versionsverwaltung, um die Transaktionsisolation zu gewährleisten.

Ursprünglichen Agent-Graphen prüfen

Um zu prüfen, ob der neu erstellte Agent-Graph korrekt kompiliert wird, können wir Antigravity auffordern, den Linter auszuführen und den Agent in unserem Namen zu testen.

👉 Prompt an Antigravity:

Run `agents-cli lint` on our `shopping-assistant` project to verify syntax and 
refactor if any issues.

Was passiert? Antigravity führt agents-cli lint und agents-cli lint --fix aus, um alle erkannten Formatierungs- oder Lint-Probleme zu beheben.

5. Projektspezifische Regeln erstellen

Damit der aktive Speicher Ihres Agents nicht mit Tausenden von Seiten generischer Sicherheitsdokumentation überlastet wird, was zu Kontextverlust und Latenz bei der Argumentation führt, müssen Sie einen „vorgefertigten Weg“ mit vorab genehmigten sicheren Konventionen einrichten. In der Antigravity IDE können Sie diese Richtlinien festlegen, indem Sie eine Kontextdatei mit persistentem Kontext erstellen.

👉 Prompt an Antigravity:

Create a customization directory named `shopping-assistant/.agents` and
create a file `shopping-assistant/.agents/CONTEXT.md` defining our secure
coding standards:

# Local Project Context & Secure Coding Standards

## Core Paved Roads
We systematically address common vulnerability classes by guiding the agent
to use our pre-configured, secure-by-default helper patterns instead of
writing raw implementation logic from scratch.

1. **Tool Input Validation**: Every agent tool must validate incoming
   parameters against strict Pydantic schemas rather than parsing raw
   dictionaries or strings.
2. **No Shell Execution**: Never use `run_command` or raw shell execution
   tools unless explicitly approved by `hooks.json`.
3. **Pre-Commit Remediation Loop**: If a git commit fails due to a pre-commit
   hook error (such as a Semgrep scan finding), you MUST treat the violation
   as a refactoring task, apply targeted fixes, run tests to verify no
   regressions, and attempt to commit again.

Erwartungen:Antigravity erstellt das Verzeichnis .agents/ und die Datei CONTEXT.md und zeigt sie direkt im Hilfsbereich zur Überprüfung an.

6. Lokale Gating-Hooks konfigurieren

Damit unsicherer Code oder vertrauliche Informationen Ihre Workstation nicht verlassen, sollten Sie vor dem Committen von Code automatisierte Gates an den Grenzen Ihrer Entwicklungsumgebung konfigurieren. Wir bitten Antigravity, die Hook-Konfigurationen zu generieren, und installieren sie dann über das Terminal.

1. Git-Pre-Commit-Hook

Damit unsere statische Analyse simulierte Anmeldedaten zuverlässig erkennt und unsichere Commits blockiert, definieren wir eine benutzerdefinierte Semgrep-Regel und konfigurieren einen Git-Pre-Commit-Hook, um sie zu erzwingen.

Benutzerdefinierte Semgrep-Regel definieren

Standard-Semgrep-Regeln (--config auto) kennzeichnen Mock-Schlüssel, die Wörter wie "mock" oder Bindestriche enthalten, aufgrund der niedrigen Zuverlässigkeitsbewertung nicht. Um unseren hartcodierten API-Schlüssel zuverlässig zu erkennen, erstellen wir eine benutzerdefinierte Datei mit lokalen Regeln, in der direkt nach regulären Ausdrücken gesucht wird, anstatt generische Regeln zu verwenden.

👉 Prompt an Antigravity:

Create a custom Semgrep rules file `shopping-assistant/.semgrep/rules.yaml`
with a rule to detect hardcoded Google API key prefixes (matching regex
`AIzaSy[A-Za-z0-9_\-]*`). Configure it for Python files with an error severity
and a clear security warning message.

Das können Sie erwarten:Antigravity erstellt shopping-assistant/.semgrep/rules.yaml, in dem unsere benutzerdefinierte Scanregel definiert wird. Sehen Sie sich die generierte Regeldefinition an:

# shopping-assistant/.semgrep/rules.yaml
rules:
  - id: detect-hardcoded-google-api-key
    pattern-regex: 'AIzaSy[A-Za-z0-9_\-]*'
    message: "Security Issue: Hardcoded Google API key prefix detected."
    languages:
      - python
    severity: ERROR

Pre-Commit-Hook konfigurieren

Konfigurieren Sie als Nächstes den Git-Pre-Commit-Hook, um unsere benutzerdefinierte Semgrep-Regel auszuführen. Wenn Hooks in einem Unterverzeichnis ausgeführt werden, müssen Pfade zu lokalen Konfigurationen relativ zum Stammverzeichnis des Git-Repositorys (shopping-assistant/.semgrep/rules.yaml) und nicht zum Unterverzeichnis des Projekts angegeben werden.

👉 Prompt an Antigravity:

Create a `shopping-assistant/.pre-commit-config.yaml` file configured to run
local pre-commit hooks (end-of-file-fixer, trailing-whitespace) and a local
Semgrep security scan on commit for Python files. Ensure Semgrep is configured
with the `--error` flag and references our custom rules file relative to the Git
repository root. Once created, run `pre-commit install` in the
terminal to activate the hooks.

Das erwartet Sie:Antigravity generiert shopping-assistant/.pre-commit-config.yaml und führt pre-commit install in Ihrem Namen aus. Sehen Sie sich die generierte Konfiguration an:

# shopping-assistant/.pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: end-of-file-fixer
        name: End of File Fixer
        entry: end-of-file-fixer
        language: system
        types: [file]
      - id: trailing-whitespace
        name: Trailing Whitespace
        entry: trailing-whitespace-fixer
        language: system
        types: [file]
      - id: semgrep
        name: Semgrep Security Scan
        entry: semgrep --error --config shopping-assistant/.semgrep/rules.yaml
        language: system
        types: [python]

Diese Konfiguration sorgt dafür, dass das Pre-Commit-Gate auch dann ausgelöst wird, wenn ein Agent im vollständig autonomen, nicht interaktiven Modus ausgeführt wird. Außerdem wird jeder Commit blockiert, der bei statischen Analysen fehlschlägt.

Befehle zur direkten Ausführung (für die manuelle Bestätigung)

Wenn Sie Ihre Einrichtung der statischen Analyse manuell überprüfen möchten, ohne einen vollständigen Commit-Hook-Zyklus auszulösen, können Sie diese Prüfungen direkt über das Terminal ausführen.

Über „pre-commit“ (aus dem Verzeichnis „shopping-assistant“):

uv run pre-commit run semgrep --all-files

Direkt über Semgrep (aus dem Verzeichnis „shopping-assistant“):

uv run semgrep --error --config .semgrep/rules.yaml app/agent.py

2. Eingebauter Antigravity-Agent-Hook

Für ein tieferes Gating in der Mitte des Ablaufs konfigurieren Sie einen Agent-Hook in shopping-assistant/.agents/hooks.json. Im Gegensatz zu Git-Hooks greifen Agent-Hooks in Antigravity ein, bevor kritische Tools (z. B. zum Ausführen von Shell-Befehlen) auf Ihrem System ausgeführt werden können.

👉 Prompt an Antigravity:

Create a `shopping-assistant/.agents/hooks.json` file configured with a
`PreToolUse` hook that intercepts `run_command` executions and runs
`python3 .agents/scripts/validate_tool_call.py` with a 10-second timeout.

Ablauf:Antigravity erstellt shopping-assistant/.agents/hooks.json. Sehen Sie sich die generierte Konfiguration an:

{
  "enabled": true,
  "PreToolUse": [
    {
      "matcher": "run_command",
      "command": "python3 .agents/scripts/validate_tool_call.py",
      "timeout": 10
    }
  ]
}

Als Nächstes fordern Sie Antigravity auf, das zugrunde liegende Tool-Validierungsskript zu erstellen, auf das unser Hook verweist.

👉 Prompt an Antigravity:

Create the script `shopping-assistant/.agents/scripts/validate_tool_call.py`
with logic to inspect `run_command` executions passed using stdin and block
destructive commands like `rm -rf /`.

Das ist zu erwarten:Antigravity generiert shopping-assistant/.agents/scripts/validate_tool_call.py, ähnlich wie unten. Sehen Sie sich das generierte Validierungsskript an:

# shopping-assistant/.agents/scripts/validate_tool_call.py
import sys
import json

def main():
    try:
        context = json.load(sys.stdin)
        command = context.get("tool_args", {}).get("CommandLine", "")
        
        if "rm -rf /" in command or "mkfs" in command:
            print("BLOCKED: Destructive command detected.", file=sys.stderr)
            sys.exit(1)
            
        print("APPROVED: Command validation passed.")
        sys.exit(0)
    except Exception as e:
        print(f"Validation error: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Vor- und Nachteile von Hooks

  • Git-Hooks: Sie sind in die Versionsverwaltung integriert und werden auch dann ausgeführt, wenn ein Agent im vollständig autonomen, nicht interaktiven Modus ausgeführt wird. Sie können jedoch mit dem Flag --no-verify während eines Commits umgangen werden.
  • Agent-Hooks: Ereignisse werden während des Ablaufs erfasst, um gefährliche Tool-Befehle zu blockieren. Sie schützen das Repository jedoch nicht, wenn ein Entwickler die IDE umgeht.

Lokale Gates fördern gute Entwicklergewohnheiten und helfen, Sicherheitslücken sofort zu erkennen. Lokale Gates können jedoch umgangen werden. Ihre Remote-CI/CD-Pipeline ist also Ihre ultimative, nicht umgehbare Sicherheitsbarriere.

7. STRIDE-Bedrohungsmodellierung implementieren

Jetzt geben Sie Antigravity das Fachwissen eines Sicherheitsarchitekten. Antigravity-Skills sind modulare, deklarative Markdown-Verzeichnisse, die dem Agenten Anweisungen zur Ausführung mehrstufiger Problemlösungs-Jobs geben. Antigravity erkennt automatisch alle Skills, die in .agents/skills/ platziert sind.

👉 Prompt an Antigravity:

Create a local skill directory
`shopping-assistant/.agents/skills/stride-threat-model/` and create a skill
definition file `shopping-assistant/.agents/skills/stride-threat-model/SKILL.md`
with the following content:

---
name: stride-threat-model
description: Performs a systematic STRIDE threat modeling assessment on the
current project's codebase and architecture. Use this when starting a new
implementation phase or reviewing existing components.
---

# STRIDE Threat Modeling Skill

## Goal
Guide the agent to analyze the workspace directory structure, configuration
files, and code files to produce a structured `threat_model.md` assessment.

## Instructions
1. **Analyze System Boundaries**: Map the entry points (tools, workflows,
   prompts) and data storage layers.
2. **STRIDE Evaluation**: Evaluate the system against the six STRIDE pillars:
   - **Spoofing**: Are caller identity boundaries verified before executing
     sensitive tool logic?
   - **Tampering**: Can users manipulate data flows, parameters, or underlying
     state?
   - **Repudiation**: Are critical transactions securely logged?
   - **Information Disclosure**: Are we risking leakage of PII, internal tokens,
     or raw stack traces?
   - **Denial of Service**: Are there rate limits on expensive database or LLM
     queries?
   - **Elevation of Privilege**: Can an unauthenticated user bypass access
     control to reach privileged tool actions?
3. **Output**: Generate a highly structured `threat_model.md` saved directly
   into the workspace root.

Das passiert: Antigravity erstellt das benutzerdefinierte Skill-Verzeichnis und die Datei SKILL.md.

Führen Sie nun den neu erstellten Skill aus, um den aktiven Projektgraphen (shopping-assistant/app/agent.py) zu bewerten.

👉 Prompt an Antigravity:

Run stride-threat-model on our shopping-assistant agent graph.

Ablauf:Antigravity entspricht Ihrer Intention, lädt die Anweisungen zur Gefahrenanalyse auf Anfrage aus Ihrem lokalen Skill-Verzeichnis, analysiert Ihre vorhandene agent.py-Datei und generiert eine strukturierte threat_model.md direkt in Ihrem shopping-assistant-Stammverzeichnis. So bleibt Ihr Arbeitskontext sauber und übersichtlich und Sie haben sofortigen Zugriff auf die Begründung von Sicherheitsexperten.

8. TDD-Planungsphase abschließen

Bevor weitere Funktionen implementiert oder Code umgestaltet wird, nutzt Antigravity sein semantisches Verständnis der Codebasis, um Änderungen in einer implementation_plan.md- und einer task.md-Checkliste abzubilden. Damit Antigravity von Anfang an auf Sicherheit ausgelegt ist, konfigurieren wir in .agents/CONTEXT.md eine Systemregel, die die Genehmigung von Plänen einschränkt.

👉 Prompt an Antigravity:

Append the following TDD planning gate instruction to the bottom of
`shopping-assistant/.agents/CONTEXT.md`:

## TDD Planning Gate
During the Plan phase, you must decompose the workspace task into logical,
modular stages. Every implementation plan MUST include a dedicated
**Security Boundaries & Assertions** section outlining specific edge cases
that could exploit the feature.

Das können Sie erwarten:Antigravity wird shopping-assistant/.agents/CONTEXT.md mit der neuen Regel für das Planungs-Gate aktualisieren.

Wenn Sie Antigravity in den folgenden Schritten auffordern, eine Funktion zu erstellen oder umzugestalten, wird diese Regel automatisch analysiert und ein Implementierungsplan mit einer expliziten Sicherheitsaufschlüsselung präsentiert. Sie können diesen Plan direkt im interaktiven Dialogfeld oder im Zusatzbereich von Antigravity überprüfen. Dort müssen Sie auf Weiter oder Genehmigen klicken, bevor die Codeerstellung beginnt.

Planungstor testen (optional)

Wenn Sie sehen möchten, wie dieses Planungstor funktioniert, können Sie Antigravity jetzt mit einer der folgenden Funktionsanfragen auffordern. Anstatt sofort Code zu generieren, wechselt Antigravity in die Planungsphase und präsentiert ein implementation_plan.md mit einer detaillierten Aufschlüsselung der Sicherheitsgrenzen und ‑zusicherungen (z. B. Identifizierung von Race Conditions, nicht autorisierter Rechteausweitung oder negativen Punktwerten) zur Überprüfung.

👉 Prompt für Antigravity (wählen Sie einen zum Testen aus):

Plan a new agent tool `award_loyalty_points` that awards points to a user's
account after a successful purchase.

Plan a new agent tool `process_cart_checkout` that receives a cart ID and
discount code, applies the discount, and processes the order.

Plan a new agent tool `update_discount_status` that allows administrators to
activate or deactivate discount codes in the store.

9. Isolierte, ergebnisorientierte Tests schreiben

Wir haben Antigravity gebeten, umfassende Sicherheitstests für unsere vorhandenen ADK-Agent-Tools zu schreiben. Damit unsere Sicherheitstests robust und realistisch sind, orientieren wir uns an zwei Grundprinzipien:

  • Ergebnisse statt Interaktionen prüfen: Prüfen Sie die endgültigen Rückgabestrings und Zustandsänderungen, anstatt fragile Mocks zu schreiben, die interne Hilfsaufrufe überwachen.
  • Strenge Schutzmaßnahmen durchsetzen: Prüfen Sie, ob Tools explizite Grenzen für die Geschäftslogik durchsetzen, z. B. Regeln für die einmalige Einlösung und registrierte Nutzer.

👉 Prompt an Antigravity:

Use `agents-cli` and pytest to generate an outcome-based security test suite
in `shopping-assistant/tests/test_agent.py`. Inspect `app/agent.py` and
write tests to verify all security boundaries and business logic guardrails
for the `redeem_discount` tool.

Das ist zu erwarten:Antigravity generiert shopping-assistant/tests/test_agent.py, ähnlich wie unten. Sehen Sie sich die generierte Testdatei an:

# shopping-assistant/tests/test_agent.py
import pytest
from app.agent import redeem_discount, DISCOUNT_STORE

@pytest.fixture(autouse=True)
def reset_store():
    """Ensure strict test isolation by resetting in-memory store state before each test run."""
    DISCOUNT_STORE["WELCOME50"] = False
    DISCOUNT_STORE["SUMMER20"] = False
    yield
    DISCOUNT_STORE["WELCOME50"] = False
    DISCOUNT_STORE["SUMMER20"] = False

def test_discount_code_can_only_be_redeemed_once():
    """Verify a user cannot submit a request reusing a single-use code."""
    # First redemption - should succeed
    res_one = redeem_discount("WELCOME50", "user_123")
    assert "Success" in res_one
    assert DISCOUNT_STORE["WELCOME50"] is True
    
    # Second redemption trying to reuse the same code
    res_two = redeem_discount("WELCOME50", "user_456")
    assert "Error: Discount code has already been redeemed" in res_two

def test_discount_redemption_rejects_invalid_code():
    """Verify that unknown discount codes are hard-blocked."""
    res = redeem_discount("INVALID999", "user_123")
    assert "Error: Invalid discount code" in res

def test_discount_redemption_rejects_guest_accounts():
    """Verify that unauthenticated guest accounts cannot redeem discounts."""
    res = redeem_discount("SUMMER20", "guest_999")
    assert "Error: Registered user account required" in res
    assert DISCOUNT_STORE["SUMMER20"] is False

TDD-GRÜN-Phase prüfen

Um zu prüfen, ob unsere neu generierten Sicherheitstests für unsere bestehende agent.py-Implementierung erfolgreich durchlaufen werden, fordern Sie Antigravity auf, pytest in Ihrem Namen auszuführen.

👉 Prompt an Antigravity:

Run `uv run pytest tests/test_agent.py` on our `shopping-assistant` project to verify that our security tests pass successfully.

Das passiert:Antigravity führt uv run pytest tests/test_agent.py im Terminal aus. Alle Testläufe werden erfolgreich abgeschlossen. Die logischen Anwendungsgrenzen sind jetzt sicher, aber wir müssen dafür sorgen, dass unser statischer Scanner den hartcodierten API-Schlüssel beim Commit erkennt.

10. Gating und Selbstkorrektur des Agents überprüfen

Nachdem die Tests grün sind, beginnt die Refactor and Commit Phase (Phase „Refaktorieren und committen“). Hier wird durch unsere lokalen Sicherheitsprüfungen und Pre-Commit-Hooks sichergestellt, dass kein Repository die Workstation mit Sicherheitslücken verlässt. Antigravity demonstriert seine autonomen Selbstkorrekturfunktionen.

  1. Navigieren Sie in Ihrem Terminal zum Projektverzeichnis und committen Sie den Code mit uv run, damit die lokalen Binärdateien für den Pre-Commit-Hook in Ihrem PATH aktiv sind:
    cd ~/secure-agent-lab/shopping-assistant
git add .
uv run git commit -m "feat: implement shopping assistant agent"
  2. Beachten Sie, dass der Commit fehlschlägt, weil der Git-Pre-Commit-Hook Semgrep automatisch ausführt:
    Semgrep Security Scan....................................................Failed
- hookid: semgrep

  app/agent.py
  Security Issue: Hardcoded Google API key prefix detected.
  3. Antigravity wird von der in .agents/CONTEXT.md konfigurierten Regel Pre-Commit Remediation Loop geleitet und fängt den Pre-Commit-Fehler automatisch im IDE-Terminal ab, liest die Semgrep-Fehlerlogs und startet einen Refactoring-Schritt, um von einem fest codierten API-Schlüssel zum sicheren Abrufen des Schlüssels zu wechseln.
  4. Sehen Sie sich den von Antigravity in shopping-assistant/app/agent.py generierten refaktorierten Code an, um das API-Schlüssel-Leck zu beheben.
  5. Antigravity führt automatisch pytest aus, um zu prüfen, ob die Tests weiterhin erfolgreich sind.
  6. Antigravity versucht, den Commit in Ihrem Namen noch einmal auszuführen. Wenn Ihre lokale Git-Identität konfiguriert und ein Repository initialisiert ist, wird der Scan bestanden und das Commit ist erfolgreich.

Dies zeigt die Leistungsfähigkeit der Kombination von TDD mit lokalen Pre-Commit-Hooks und Agent-Schleifen. Anstatt auf einen Remote-CI/CD-Fehler zu warten, wird der Agent lokal zur Rechenschaft gezogen und sein Code wird so umgestaltet, dass er standardmäßig sicher ist, bevor er überhaupt übertragen wird.

11. Agent lokal ausführen und testen

Nachdem die Sicherheitsgrenzen überprüft und übernommen wurden, führen Sie den ADK-Agenten lokal mit Ihrem exportierten Gemini API-Schlüssel aus, um im lokalen Playground mit ihm zu interagieren.

  1. Prüfen Sie im Terminal, ob Ihr Gemini API-Schlüssel in Ihrer Umgebung exportiert wurde:
    echo $GEMINI_API_KEY # Verify your key is exported
  2. Starten Sie den lokalen Entwicklungs-Playground für Ihren Agenten:
    cd ~/secure-agent-lab/shopping-assistant
agents-cli playground
    Sie sollten eine Ausgabe sehen, die angibt, dass der lokale Playground-Server auf Port 8080 ausgeführt wird:
    * Serving ADK Playground
* Running on http://127.0.0.1:8080/dev-ui/?app=app
  3. Öffnen Sie die angegebene URL in Ihrem Webbrowser, um interaktiv mit Ihrem Shopping Assistant-Agenten zu chatten. Sie können es beispielsweise bitten, einen Rabattcode einzulösen:
    Can you redeem the discount code WELCOME50 for user user_123?
    Der Agent verarbeitet Ihre Anfrage mit der Ausführung des Gemini-Modells und versucht, den Rabatt einzulösen.

12. Bereinigen

Führen Sie die folgenden Bereinigungsschritte aus, um Ihre Workstation zu bereinigen und zu vermeiden, dass unerwünschte Ressourcen oder vertrauliche Informationen in Ihrer lokalen Umgebung verbleiben.

  1. Lokalen Server beenden: Wenn Ihr Playground-Server noch ausgeführt wird, beenden Sie ihn im Terminal, indem Sie Ctrl + C drücken.
  2. Lokale Projektdateien entfernen: Löschen Sie das lokale Projektverzeichnis von Ihrem Computer: 
    rm -rf ~/secure-agent-lab

13. Glückwunsch

Glückwunsch! Sie haben mit der Google Antigravity IDE einen sicheren, testorientierten Entwicklungszyklus eingerichtet, einen reinen ADK 2.0-Shopping-Assistenten-Agenten erstellt und ihn lokal überprüft.

Das haben Sie gelernt

  • So erstellen und integrieren Sie einen ADK 2.0-Agenten (ADK) mit der Antigravity IDE und agents-cli.
  • So richten Sie mit CONTEXT.md sichere Codierungsstandards auf Projektebene ein.
  • Benutzerdefiniertes STRIDE-Skill für die Bedrohungsmodellierung in Antigravity IDE erstellen und ausführen
  • So schränken Sie die Planungsphase eines KI-Agenten ein, um Sicherheitsgrenzen zu erzwingen.
  • Isolierte, ergebnisbasierte Sicherheitstests mit pytest implementieren
  • So führen Sie die Agent-Anwendung lokal aus und testen sie.
  • Die Unterschiede und Kompromisse zwischen Git-Hooks und agentspezifischen Ausführungshooks.

Nächste Schritte

Kaggle-Auszeichnung „5-Day AI Agents“ erhalten 🎉

Haben Sie dieses Lab im Rahmen des 5-Day AI Agents: Intensive Vibe Coding Course with Google von Kaggle absolviert? So fordern Sie Ihr Abzeichen für die erfolgreiche Teilnahme an:

5-Day AI Agents Badge