Vibecode e Proteggere il ciclo di vita di un agente AI con Antigravity e TDD

1. Introduzione

In questo codelab, creerai un'applicazione web per la vendita al dettaglio con un assistente per lo shopping AI integrato utilizzando Agent Development Kit (ADK) di Google. Utilizzerai Google Antigravity IDE (l'IDE agentico di Google) per stabilire un flusso di lavoro di sviluppo sicuro e basato sui test (TDD).

Anziché trattare la sicurezza come un gate di fine ciclo, imparerai a "spostare la sicurezza a sinistra" fino al punto di creazione del codice. Applicherai gli standard di sviluppo, automatizzerai la modellazione delle minacce STRIDE e controllerai le azioni dell'agente con hook pre-commit di Git e hook di esecuzione specifici dell'agente.

In questo lab proverai a:

  • Crea e genera un agente assistente per lo shopping ADK 2.0 utilizzando Antigravity IDE e agents-cli.
  • Configura standard di codifica sicuri a livello di progetto utilizzando un file di contesto persistente (CONTEXT.md).
  • Crea e richiama una competenza di modellazione delle minacce STRIDE personalizzata a livello di spazio di lavoro in Antigravity IDE.
  • Applica le barriere di sicurezza direttamente durante la fase di pianificazione del TDD.
  • Scrivi test di sicurezza basati sui risultati in Pytest utilizzando Antigravity.
  • Configura i pre-commit hook di Git per automatizzare le scansioni Semgrep con cicli di correzione locali in Antigravity.

Che cosa ti serve

  • Un browser web come Chrome
  • Familiarità con Python, Pytest e i comandi di base del terminale
  • Google Antigravity IDE installato. Consulta il sito web ufficiale.
  • Gestore di pacchetti uv installato. Consulta la guida all'installazione di uv.
  • Strumento a riga di comando Git installato. Git viene utilizzato esclusivamente per il controllo della versione locale in questo lab, pertanto non è necessario un account GitHub. Consulta la guida all'installazione di Git.

Questo codelab è rivolto a sviluppatori di tutti i livelli, inclusi i principianti. Il completamento dell'intero lab richiede circa 60 minuti.

Configurare l'autenticazione e l'ambiente

Fornisci le credenziali di autenticazione per consentire all'agente di chiamare i modelli Gemini. Ottieni una chiave API Gemini standard da Google AI Studio ed esportala nella sessione del terminale IDE:

export GEMINI_API_KEY="your_api_key_here"
export GOOGLE_GENAI_USE_ENTERPRISE=FALSE

2. Configura Workspace e la toolchain

Per prima cosa, inizializza lo spazio di lavoro del progetto e installa la toolchain di gestione degli agenti sottostante. Per farlo, chiederemo ad Antigravity IDE di automatizzare la procedura di configurazione.

👉 Prompt per 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`.

Cosa aspettarsi:Antigravity eseguirà i comandi del terminale necessari per tuo conto, creando un repository Git pulito e installando le competenze ADK complementari nel tuo IDE.

3. Crea lo scaffolding del progetto di agente ADK

In questa fase, guidiamo Antigravity a utilizzare agents-cli per creare un progetto di agente ADK 2.0 completamente funzionante chiamato shopping-assistant. Chiederemo ad Antigravity di progettare un assistente per la vendita al dettaglio con uno strumento di utilizzo degli sconti.

Nota:per mostrare la potenza degli hook di gating automatizzati, in questo prompt chiediamo esplicitamente ad Antigravity di includere una vulnerabilità simulata: una chiave API di test hardcoded utilizzata per lo sviluppo locale.

👉 Prompt per 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"`.

Cosa aspettarsi: Antigravity eseguirà agents-cli scaffold create shopping-assistant --adk, configurerà pyproject.toml e implementerà la logica dell'agente.

4. Esplorare il codice dell'agente

👉 Chiedi ad Antigravity di spiegare il codice generato:

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.

Nell'IDE Antigravity, i file di progetto appena creati vengono visualizzati direttamente nel riquadro ausiliario (a sinistra). Puoi visualizzarlo shopping-assistant/app/agent.py o aprirlo da Esplora file dell'IDE.

# 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 practice di produzione: concorrenza e condizioni di competizione

Nella logica del nostro strumento, controlliamo un dizionario in memoria (DISCOUNT_STORE) e ne modifichiamo lo stato. In un ambiente di produzione multithread con un database reale, due richieste simultanee potrebbero leggere il codice come non riscattato prima di eseguire il commit della scrittura, causando una vulnerabilità di doppio riscatto. In produzione, utilizza sempre il blocco pessimistico (ad es. .with_for_update()) o il controllo delle versioni ottimistico per garantire l'isolamento delle transazioni.

Esegui il lint del grafico dell'agente iniziale

Per verificare che il grafico dell'agente appena creato venga compilato correttamente, possiamo chiedere ad Antigravity di eseguire il linter e testare l'agente per nostro conto.

👉 Prompt per Antigravity:

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

Cosa aspettarsi: Antigravity eseguirà agents-cli lint e agents-cli lint --fix per correggere eventuali problemi di formattazione o di lint rilevati.

5. Creare regole specifiche per il progetto

Per evitare di sovraccaricare la memoria attiva dell'agente con migliaia di pagine di documentazione generica sulla sicurezza, che causa il deterioramento del contesto e la latenza del ragionamento, devi stabilire una "strada asfaltata" di convenzioni sicure pre-approvate. In Antigravity IDE, puoi stabilire queste misure di protezione creando un file di contesto persistente.

👉 Prompt per 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.

Cosa aspettarsi:Antigravity creerà la directory .agents/ e il file CONTEXT.md, visualizzandoli direttamente nel riquadro ausiliario per la revisione.

6. Configurare gli hook di gating locali

Per impedire che codice o segreti non sicuri escano dalla tua workstation, configura porte automatizzate ai limiti del tuo ambiente di sviluppo prima di eseguire il commit del codice. Chiederemo ad Antigravity di generare le configurazioni degli hook, quindi le installeremo utilizzando il terminale.

1. Hook pre-commit Git

Per garantire che la nostra analisi statica rilevi in modo affidabile le credenziali simulate e blocchi i commit non sicuri, definiremo una regola Semgrep personalizzata e configureremo un hook pre-commit Git per applicarla.

Definire una regola Semgrep personalizzata

Le regole Semgrep predefinite (--config auto) non segnalano le chiavi simulate contenenti parole come "mock" o trattini a causa del punteggio di bassa confidenza. Per rilevare in modo affidabile la nostra chiave API hardcoded, creeremo un file di regole locali personalizzato utilizzando la scansione diretta delle espressioni regolari anziché regole generiche.

👉 Prompt per 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.

Cosa aspettarsi: Antigravity creerà shopping-assistant/.semgrep/rules.yaml definendo la nostra regola di scansione personalizzata. Rivedi la definizione della regola generata:

# 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

Configura il hook di pre-commit

Successivamente, configura l'hook pre-commit di Git per eseguire la nostra regola Semgrep personalizzata. Quando esegui hook in un layout di sottodirectory, i percorsi delle configurazioni locali devono essere relativi alla directory principale del repository Git (shopping-assistant/.semgrep/rules.yaml), non alla sottodirectory del progetto.

👉 Prompt per 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.

Che cosa aspettarsi:Antigravity genererà shopping-assistant/.pre-commit-config.yaml ed eseguirà pre-commit install per tuo conto. Rivedi la configurazione generata:

# 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]

Questa configurazione garantisce che, anche se un agente è in esecuzione in modalità completamente autonoma e non interattiva, il gate pre-commit si attivi e blocchi qualsiasi commit che non supera le scansioni di analisi statica.

Comandi di esecuzione diretta (per la verifica manuale)

Per verificare manualmente la configurazione dell'analisi statica senza attivare un ciclo completo di hook di commit, puoi eseguire questi controlli direttamente dal terminale.

Tramite pre-commit (dalla directory "shopping-assistant"):

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

Direttamente tramite Semgrep (dalla directory "shopping-assistant"):

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

2. Gancio per l'agente Antigravity integrato

Per un gating più profondo a metà traiettoria, configura un hook dell'agente in shopping-assistant/.agents/hooks.json. A differenza degli hook Git, gli hook dell'agente intercettano Antigravity prima che possa eseguire strumenti critici (come l'esecuzione di comandi shell) sul tuo sistema.

👉 Prompt per 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.

Cosa aspettarsi:Antigravity creerà shopping-assistant/.agents/hooks.json. Rivedi la configurazione generata:

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

Successivamente, chiedi ad Antigravity di creare lo script di convalida dello strumento sottostante a cui fa riferimento il nostro hook.

👉 Prompt per 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 /`.

Cosa aspettarsi:Antigravity genererà shopping-assistant/.agents/scripts/validate_tool_call.py, simile a quello riportato di seguito. Rivedi lo script di convalida generato:

# 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()

Compromessi degli hook

  • Hook Git: nativi del controllo della versione; vengono eseguiti anche se un agente viene eseguito in modalità completamente autonoma e non interattiva. Tuttavia, possono essere ignorati utilizzando il flag --no-verify durante un commit.
  • Hook degli agenti: acquisiscono gli eventi a metà della traiettoria per bloccare i comandi degli strumenti pericolosi, ma non proteggono il repository se uno sviluppatore aggira l'IDE.

I gate locali rafforzano le buone abitudini degli sviluppatori e aiutano a rilevare immediatamente le vulnerabilità. Ricorda, tuttavia, che i gate locali possono essere aggirati, il che significa che la tua pipeline CI/CD remota e isolata rimane la tua barriera di sicurezza definitiva e non aggirabile.

7. Implementare la competenza di modellazione delle minacce STRIDE

Ora, concederai ad Antigravity le conoscenze specialistiche di un architetto della sicurezza. Le competenze Antigravity sono directory Markdown modulari e dichiarative che indicano all'agente come eseguire job di ragionamento multi-step. Antigravity rileva automaticamente le competenze inserite in .agents/skills/.

👉 Prompt per 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.

Che cosa aspettarsi:Antigravity creerà la directory delle skill personalizzate e il file SKILL.md.

Ora eseguiamo la skill appena creata per valutare il grafico del progetto attivo (shopping-assistant/app/agent.py).

👉 Prompt per Antigravity:

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

Cosa aspettarsi: Antigravity corrisponde alla tua intenzione, carica le istruzioni di valutazione delle minacce on demand dalla directory delle skill locali, analizza il file agent.py esistente e genera un threat_model.md strutturato direttamente nella directory root shopping-assistant. Questo approccio mantiene il tuo contesto di lavoro quotidiano pulito e leggero, offrendoti al contempo l'accesso immediato al ragionamento di esperti in materia di sicurezza.

8. Bloccare la fase di pianificazione del TDD

Prima di implementare altre funzionalità o eseguire il refactoring del codice, Antigravity utilizza la sua comprensione semantica del codebase per mappare le modifiche in un implementation_plan.md e in un elenco di controllo task.md. Per forzare Antigravity a progettare la sicurezza in anticipo, configuriamo una regola di sistema in .agents/CONTEXT.md che limita l'approvazione del piano.

👉 Prompt per 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.

Cosa aspettarsi: Antigravity aggiornerà shopping-assistant/.agents/CONTEXT.md con la nuova regola del gate di pianificazione.

Quando chiedi ad Antigravity di creare o rifattorizzare una funzionalità nei passaggi successivi, analizza automaticamente questa regola e presenta un piano di implementazione con una suddivisione esplicita della sicurezza. Potrai esaminare questo piano direttamente nella finestra di dialogo interattiva o nel riquadro ausiliario di Antigravity, dove devi fare clic su Procedi o Approva prima che inizi la generazione del codice.

Testare il Planning Gate (facoltativo)

Per osservare questo gate di pianificazione in azione in questo momento, prova a chiedere ad Antigravity una delle seguenti richieste di funzionalità. Anziché generare immediatamente il codice, Antigravity entrerà nella fase di pianificazione e mostrerà un implementation_plan.md con un'analisi dettagliata di limiti e asserzioni di sicurezza (ad es.identificazione di race condition, escalation non autorizzata dei privilegi o valori di punti negativi) da esaminare.

👉 Prompt per Antigravity (scegli un'opzione da testare):

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. Scrivere test isolati e basati sui risultati

Ora guidiamo Antigravity nella scrittura di test di sicurezza completi per i nostri strumenti di agenti ADK esistenti. Per garantire che i nostri test di sicurezza siano resilienti e realistici, li strutturiamo in base a due principi fondamentali:

  • Afferma i risultati, non le interazioni: afferma le stringhe di ritorno finali e le mutazioni di stato anziché scrivere simulazioni fragili che spiano le chiamate di helper interni.
  • Applica barriere di protezione rigorose: verifica che gli strumenti applichino limiti espliciti alla logica di business (ad esempio, regole per il riscatto monouso e per gli utenti registrati).

👉 Prompt per 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.

Cosa aspettarsi:Antigravity genererà shopping-assistant/tests/test_agent.py, simile a quello riportato di seguito. Rivedi il file di test generato:

# 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

Verifica della fase VERDE di TDD

Per verificare che i nostri test di sicurezza appena generati vengano superati correttamente rispetto alla nostra implementazione agent.py esistente, chiedi ad Antigravity di eseguire pytest per tuo conto.

👉 Prompt per Antigravity:

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

Cosa aspettarsi: Antigravity eseguirà uv run pytest tests/test_agent.py nel terminale. Tutti gli scenari di test vengono superati. I limiti logici dell'applicazione ora sono sicuri, ma dobbiamo assicurarci che lo scanner statico rilevi la chiave API hardcoded durante il commit.

10. Verifica di Gating e correzione automatica dell'agente

Ora che i test sono verdi, entri nella fase di refactoring e commit. È qui che le nostre scansioni di sicurezza locali e gli hook pre-commit verificano che nessun repository lasci la workstation con vulnerabilità e Antigravity dimostra le sue capacità di autocorrezione autonoma.

  1. Nel terminale, vai alla directory del progetto ed esegui il commit del codice utilizzando uv run per assicurarti che i file binari dell'hook pre-commit locale siano attivi nel PATH:
    cd ~/secure-agent-lab/shopping-assistant
git add .
uv run git commit -m "feat: implement shopping assistant agent"
  2. Osserva che il commit non va a buon fine perché l'hook pre-commit di Git esegue automaticamente Semgrep:
    Semgrep Security Scan....................................................Failed
- hookid: semgrep

  app/agent.py
  Security Issue: Hardcoded Google API key prefix detected.
  3. Guidato dalla regola Pre-Commit Remediation Loop configurata in .agents/CONTEXT.md, Antigravity intercetta automaticamente l'errore di pre-commit nel terminale IDE, legge i log degli errori di Semgrep e avvia un passaggio di refactoring per passare da una chiave API hardcoded al recupero sicuro della chiave.
  4. Esamina il codice sottoposto a refactoring generato da Antigravity in shopping-assistant/app/agent.py per risolvere la perdita della chiave API.
  5. Antigravity esegue automaticamente pytest per verificare che i test siano ancora verdi.
  6. Antigravity tenta di eseguire nuovamente il commit per tuo conto. Se la tua identità Git locale è configurata e un repository è inizializzato, la scansione viene superata e il commit va a buon fine.

Ciò dimostra la potenza principale della combinazione di TDD con hook pre-commit locali e loop dell'agente. Invece di attendere un errore CI/CD remoto, l'agente viene mantenuto responsabile a livello locale, eseguendo il refactoring del codice in modo che sia sicuro per impostazione predefinita prima di essere inviato.

11. Esegui e testa l'agente in locale

Ora che i limiti di sicurezza sono verificati e confermati, esegui l'agente ADK localmente utilizzando la chiave API Gemini esportata per interagire con lui nel playground locale.

  1. Nel terminale, assicurati che la chiave API Gemini sia esportata nel tuo ambiente:
    echo $GEMINI_API_KEY # Verify your key is exported
  2. Avvia il playground di sviluppo locale per il tuo agente:
    cd ~/secure-agent-lab/shopping-assistant
agents-cli playground
    Dovresti visualizzare un output che indica che il server playground locale è in esecuzione sulla porta 8080:
    * Serving ADK Playground
* Running on http://127.0.0.1:8080/dev-ui/?app=app
  3. Apri l'URL fornito nel browser web per iniziare a chattare in modo interattivo con l'agente Shopping Assistant. Prova a chiedergli di utilizzare un codice sconto:
    Can you redeem the discount code WELCOME50 for user user_123?
    L'agente elaborerà la tua richiesta utilizzando l'esecuzione del modello Gemini e tenterà di riscattare lo sconto.

12. Esegui la pulizia

Per liberare spazio sulla workstation ed evitare di lasciare risorse o secret indesiderati nell'ambiente locale, segui questi passaggi di pulizia.

  1. Arresta server locale: se il server playground è ancora in esecuzione, arrestalo nel terminale premendo Ctrl + C.
  2. Rimuovi file di progetto locali: elimina la directory del progetto locale dalla macchina: 
    rm -rf ~/secure-agent-lab

13. Complimenti

Complimenti! Hai stabilito correttamente un ciclo di vita di sviluppo sicuro e basato sui test utilizzando Google Antigravity IDE, hai creato un agente assistente allo shopping ADK 2.0 puro e lo hai verificato localmente.

Cosa hai imparato

  • Come creare e integrare un agente ADK 2.0 (ADK) utilizzando l'IDE Antigravity e agents-cli.
  • Come configurare standard di codifica sicura a livello di progetto utilizzando CONTEXT.md.
  • Come creare ed eseguire una competenza di modellazione delle minacce STRIDE personalizzata in Antigravity IDE.
  • Come controllare la fase di pianificazione di un agente AI per applicare i limiti di sicurezza.
  • Come implementare test di sicurezza isolati e basati sui risultati utilizzando pytest.
  • Come eseguire e testare l'applicazione con agenti in locale.
  • Le differenze e i compromessi tra gli hook Git e gli hook di esecuzione specifici dell'agente.

Passaggi successivi

Ottieni il badge Agenti AI di Kaggle in 5 giorni 🎉

Hai completato questo lab nell'ambito del corso intensivo di programmazione 5-Day AI Agents: Intensive Vibe Coding Course with Google di Kaggle? Richiedi il tuo badge di completamento:

Ottieni il badge Agenti AI di 5 giorni