Vibecode y protección del ciclo de vida de un agente de IA con Antigravity y TDD

1. Introducción

En este codelab, crearás una aplicación web de venta minorista con un asistente de compras integrado basado en IA usando el Kit de desarrollo de agentes (ADK) de Google. Usarás el IDE de Google Antigravity (el IDE basado en agentes de Google) para establecer un flujo de trabajo seguro y basado en pruebas (TDD).

En lugar de tratar la seguridad como una puerta de etapa tardía, aprenderás a "desplazar la seguridad hacia la izquierda" hasta el punto de inicio del código. Aplicarás los estándares de desarrollo, automatizarás el modelado de amenazas STRIDE y controlarás las acciones del agente con hooks de preconfirmación de Git y hooks de ejecución específicos del agente.

Actividades

  • Crea un agente asistente de compras con ADK 2.0 usando el IDE de Antigravity y agents-cli.
  • Configura estándares de programación seguros a nivel del proyecto con un archivo de contexto persistente (CONTEXT.md).
  • Compila e invoca una habilidad personalizada de modelado de amenazas STRIDE a nivel del espacio de trabajo en el IDE de Antigravity.
  • Aplica barreras de seguridad directamente durante la fase de planificación de la TDD.
  • Escribe pruebas de seguridad basadas en resultados en Pytest con Antigravity.
  • Configura hooks de confirmación previa de Git para automatizar los análisis de Semgrep con bucles de corrección locales en Antigravity.

Requisitos

  • Un navegador web, como Chrome
  • Conocimiento de Python, Pytest y comandos básicos de la terminal
  • IDE de Google Antigravity instalado Consulta el sitio web oficial.
  • El administrador de paquetes uv está instalado. Consulta la guía de instalación de UV.
  • La herramienta de línea de comandos de Git debe estar instalada. En este lab, Git se usa exclusivamente para el control de versiones local, por lo que no se requiere una cuenta de GitHub. Consulta la guía de instalación de Git.

Este codelab es para desarrolladores de todos los niveles, incluidos los principiantes. Completar todo el lab te llevará aproximadamente 60 minutos.

Configura la autenticación y el entorno

Proporciona tus credenciales de autenticación para que el agente llame a los modelos de Gemini. Obtén una clave de API de Gemini estándar de Google AI Studio y expórtala en la sesión de la terminal de tu IDE:

export GEMINI_API_KEY="your_api_key_here"
export GOOGLE_GENAI_USE_ENTERPRISE=FALSE

2. Configura Workspace y la cadena de herramientas

Primero, inicializa el espacio de trabajo del proyecto y, luego, instala la cadena de herramientas subyacente de administración de agentes. Para ello, le pediremos al IDE de Antigravity que automatice el proceso de configuración.

👉 Instrucción para 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`.

Qué esperar: Antigravity ejecutará los comandos de terminal necesarios en tu nombre, establecerá un repositorio de Git limpio y, luego, instalará las habilidades complementarias del ADK en tu IDE.

3. Crea la estructura del proyecto del agente del ADK

En esta fase, guiamos a Antigravity para que use agents-cli y cree un proyecto de agente de ADK 2.0 completamente funcional llamado shopping-assistant. Le indicaremos a Antigravity que diseñe un asistente de venta minorista con una herramienta de canje de descuentos.

Nota: Para mostrar el poder de los hooks de bloqueo automatizados, en esta instrucción, le indicamos explícitamente a Antigravity que incluya una vulnerabilidad simulada: una clave de API simulada codificada que se usa para el desarrollo local.

👉 Instrucción para 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"`.

Qué esperar: Antigravity ejecutará agents-cli scaffold create shopping-assistant --adk, configurará pyproject.toml y, luego, implementará la lógica del agente.

4. Explora el código del agente

👉 Pídele a Antigravity que explique el código generado:

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.

En el IDE de Antigravity, los archivos del proyecto recién creados se muestran directamente en el panel auxiliar (lado izquierdo). Puedes ver shopping-assistant/app/agent.py allí o abrirlo desde el explorador de archivos del 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
)

Práctica recomendada de producción: Simultaneidad y condiciones de carrera

En la lógica de nuestra herramienta, verificamos un diccionario en memoria (DISCOUNT_STORE) y modificamos su estado. En un entorno de producción multiproceso con una base de datos real, dos solicitudes simultáneas podrían leer el código como no canjeado antes de que se confirmen las escrituras, lo que provocaría una vulnerabilidad de canje doble. En producción, siempre usa el bloqueo pesimista (p.ej., .with_for_update()) o el control de versiones optimista para garantizar el aislamiento de transacción.

Realiza el análisis de código del gráfico de agente inicial

Para verificar que el gráfico del agente recién creado se compile correctamente, podemos pedirle a Antigravity que ejecute el verificador de código y pruebe el agente en nuestro nombre.

👉 Instrucción para Antigravity:

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

Qué esperar: Antigravity ejecutará agents-cli lint y agents-cli lint --fix para corregir cualquier problema de formato o de lint detectado.

5. Crea reglas específicas del proyecto

Para evitar sobrecargar la memoria activa de tu agente con miles de páginas de documentación de seguridad genérica, lo que provoca deterioro del contexto y latencia en el razonamiento, debes establecer una "ruta pavimentada" de convenciones seguras aprobadas previamente. En el IDE de Antigravity, puedes establecer estas medidas de protección creando un archivo de contexto persistente.

👉 Instrucción para 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.

Qué sucederá: Antigravity creará el directorio .agents/ y el archivo CONTEXT.md, y los mostrará directamente en el panel auxiliar para que los revises.

6. Cómo configurar hooks de Local Gating

Para evitar que el código o los secretos no seguros salgan de tu estación de trabajo, configura puertas automáticas en los límites de tu entorno de desarrollo antes de confirmar el código. Le pediremos a Antigravity que genere las configuraciones de gancho y, luego, las instalaremos con la terminal.

1. Hook de confirmación previa de Git

Para garantizar que nuestro análisis estático detecte de forma confiable las credenciales simuladas y bloquee las confirmaciones no seguras, definiremos una regla personalizada de Semgrep y configuraremos un gancho previo a la confirmación de Git para aplicarla.

Cómo definir una regla de Semgrep personalizada

Las reglas predeterminadas de Semgrep (--config auto) no marcan las claves simuladas que contienen palabras como "mock" o guiones debido a la baja puntuación de confianza. Para detectar de forma confiable nuestra clave de API codificada, crearemos un archivo de reglas local personalizado que utilice el análisis directo de regex en lugar de reglas genéricas.

👉 Instrucción para 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.

Qué esperar: Antigravity creará shopping-assistant/.semgrep/rules.yaml que definirá nuestra regla de análisis personalizada. Revisa la definición de regla generada:

# 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 el hook de confirmación previa

A continuación, configura el hook de confirmación previa de Git para ejecutar nuestra regla personalizada de Semgrep. Cuando se ejecutan hooks en un diseño de subdirectorios, las rutas de acceso a las configuraciones locales deben ser relativas al directorio raíz del repositorio de Git (shopping-assistant/.semgrep/rules.yaml), no al subdirectorio del proyecto.

👉 Instrucción para 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.

Qué esperar: Antigravity generará shopping-assistant/.pre-commit-config.yaml y ejecutará pre-commit install en tu nombre. Revisa la configuración generada:

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

Esta configuración garantiza que, incluso si un agente se ejecuta en modo completamente autónomo y no interactivo, la puerta de confirmación previa se activará y bloqueará cualquier confirmación que no supere los análisis estáticos.

Comandos de ejecución directa (para la verificación manual)

Para verificar manualmente la configuración del análisis estático sin activar un ciclo completo de hooks de confirmación, puedes ejecutar estas verificaciones directamente desde la terminal.

Con pre-commit (desde el directorio "shopping-assistant"):

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

Directamente a través de Semgrep (desde el directorio "shopping-assistant"):

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

2. Hook del agente de Antigravity integrado

Para una segmentación más profunda y a mitad de la trayectoria, configura un gancho del agente en shopping-assistant/.agents/hooks.json. A diferencia de los hooks de Git, los hooks del agente interceptan Antigravity antes de que pueda ejecutar herramientas críticas (como comandos de shell) en tu sistema.

👉 Instrucción para 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.

Qué esperar: Antigravity creará shopping-assistant/.agents/hooks.json. Revisa la configuración generada:

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

A continuación, pídele a Antigravity que cree el script de validación de la herramienta subyacente al que hace referencia nuestro gancho.

👉 Instrucción para 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 /`.

Qué esperar: Antigravity generará shopping-assistant/.agents/scripts/validate_tool_call.py, similar al que se muestra a continuación. Revisa la secuencia de comandos de validación generada:

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

Compensaciones de los hooks

  • Git Hooks: Son nativos del control de versiones y se ejecutan incluso si un agente se ejecuta en modo completamente autónomo y no interactivo. Sin embargo, se pueden omitir con la marca --no-verify durante una confirmación.
  • Agent Hooks: Capturan eventos a mitad de la trayectoria para bloquear comandos de herramientas peligrosos, pero no protegen el repositorio si un desarrollador omite el IDE.

Las verificaciones locales refuerzan los buenos hábitos de los desarrolladores y ayudan a detectar vulnerabilidades de inmediato. Sin embargo, recuerda que las puertas locales se pueden omitir, lo que significa que tu canalización de CI/CD remota y aislada sigue siendo tu barrera de seguridad definitiva e ineludible.

7. Implementa la habilidad de modelado de amenazas STRIDE

Ahora, le otorgarás a Antigravity el conocimiento especializado de un arquitecto de seguridad. Las habilidades de antigravedad son directorios de Markdown declarativos y modulares que le indican al agente cómo ejecutar trabajos de razonamiento de varios pasos. Antigravity descubre automáticamente las habilidades colocadas en .agents/skills/.

👉 Instrucción para 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.

Qué sucederá: Antigravity creará el directorio de habilidades personalizadas y el archivo SKILL.md.

Ahora, ejecutemos la habilidad que acabas de crear para evaluar el gráfico de tu proyecto activo (shopping-assistant/app/agent.py).

👉 Instrucción para Antigravity:

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

Qué esperar: Antigravity coincide con tu intención, carga las instrucciones de evaluación de amenazas a pedido desde tu directorio de habilidades local, analiza tu archivo agent.py existente y genera un threat_model.md estructurado directamente en la raíz de shopping-assistant. Este enfoque mantiene tu contexto de trabajo diario limpio y ligero, a la vez que te brinda acceso instantáneo a razonamientos de seguridad expertos.

8. Puerta de la fase de planificación del TDD

Antes de implementar más funciones o refactorizar el código, Antigravity utiliza su comprensión semántica de la base de código para asignar los cambios en una lista de verificación de implementation_plan.md y task.md. Para obligar a Antigravity a diseñar la seguridad desde el principio, configuramos una regla del sistema en .agents/CONTEXT.md que restringe la aprobación del plan.

👉 Instrucción para 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.

Qué esperar: Antigravity actualizará shopping-assistant/.agents/CONTEXT.md con la nueva regla de puerta de planificación.

Cuando le pidas a Antigravity que compile o refactorice una función en pasos posteriores, analizará automáticamente esta regla y presentará un plan de implementación con un desglose explícito de la seguridad. Podrás revisar este plan directamente en el diálogo interactivo o el panel auxiliar de Antigravity, en el que debes hacer clic en Continuar o Aprobar antes de que comience la generación de código.

Prueba la puerta de planificación (opcional)

Para observar esta puerta de planificación en acción ahora mismo, intenta darle a Antigravity una de las siguientes solicitudes de funciones. En lugar de generar código de inmediato, Antigravity entrará en la fase de planificación y presentará un implementation_plan.md con un desglose detallado de los límites y las aserciones de seguridad (p. ej., identificación de condiciones de carrera, escalación de privilegios no autorizada o valores de puntos negativos) para que lo revises.

👉 Instrucción para Antigravity (elige una para probar):

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. Escribe pruebas aisladas basadas en resultados

Ahora, guiamos a Antigravity para que escriba pruebas de seguridad integrales para nuestras herramientas existentes del agente del ADK. Para garantizar que nuestras pruebas de seguridad sean resilientes y realistas, las estructuramos en función de dos principios fundamentales:

  • Afirma sobre los resultados, no sobre las interacciones: Afirma sobre las cadenas de devolución finales y las mutaciones de estado en lugar de escribir simulaciones frágiles que espían las llamadas internas de ayuda.
  • Aplicar medidas de protección estrictas: Verifica que las herramientas apliquen límites explícitos de la lógica empresarial (como reglas de canje de un solo uso y de usuarios registrados).

👉 Instrucción para 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.

Qué esperar: Antigravity generará shopping-assistant/tests/test_agent.py, similar al que se muestra a continuación. Revisa el archivo de prueba generado:

# 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 la fase VERDE de la TDD

Para verificar que nuestras pruebas de seguridad recién generadas se aprueben correctamente en nuestra implementación de agent.py existente, pídele a Antigravity que ejecute pytest en tu nombre.

👉 Instrucción para Antigravity:

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

Qué esperar: Antigravity ejecutará uv run pytest tests/test_agent.py en la terminal. Todos los casos de prueba se aprobaron correctamente. Los límites lógicos de la aplicación ahora son seguros, pero debemos asegurarnos de que nuestro analizador estático detecte la clave de API codificada durante la confirmación.

10. Verifica la corrección automática y la restricción de acceso del agente

Ahora que las pruebas están en verde, ingresa a la Fase de refactorización y confirmación. Aquí es donde nuestros análisis de seguridad locales y hooks previos a la confirmación verifican que ningún repositorio salga de la estación de trabajo con vulnerabilidades, y Antigravity demuestra sus capacidades autónomas de autocorrección.

  1. En la terminal, navega al directorio del proyecto y confirma el código con uv run para asegurarte de que los archivos binarios del hook previo a la confirmación local estén activos en tu PATH:
    cd ~/secure-agent-lab/shopping-assistant
git add .
uv run git commit -m "feat: implement shopping assistant agent"
  2. Observa que la confirmación falla porque el gancho previo a la confirmación de Git ejecuta Semgrep automáticamente:
    Semgrep Security Scan....................................................Failed
- hookid: semgrep

  app/agent.py
  Security Issue: Hardcoded Google API key prefix detected.
  3. Guiado por la regla Pre-Commit Remediation Loop configurada en .agents/CONTEXT.md, Antigravity intercepta automáticamente el error previo a la confirmación en la terminal del IDE, lee los registros de errores de Semgrep y comienza un paso de refactorización para pasar de una clave de API codificada de forma rígida a recuperar la clave de forma segura.
  4. Revisa el código refactorizado que generó Antigravity en shopping-assistant/app/agent.py para resolver la filtración de la clave de API.
  5. Antigravity ejecuta pytest automáticamente para verificar que las pruebas sigan siendo correctas.
  6. Antigravity vuelve a intentar la confirmación en tu nombre. Si tu identidad de Git local está configurada y se inicializó un repositorio, el análisis se aprobará y la confirmación se realizará correctamente.

Esto demuestra el poder fundamental de combinar el TDD con los bucles de agentes y los hooks locales previos a la confirmación. En lugar de esperar a que falle el CI/CD remoto, el agente se mantiene responsable a nivel local y refactoriza su código para que sea seguro de forma predeterminada antes de que se envíe.

11. Ejecuta y prueba el agente de forma local

Ahora que los límites de seguridad se verificaron y confirmaron, ejecuta el agente del ADK de forma local con la clave de la API de Gemini que exportaste para interactuar con él en el Playground local.

  1. En tu terminal, asegúrate de que tu clave de API de Gemini se haya exportado en tu entorno:
    echo $GEMINI_API_KEY # Verify your key is exported
  2. Inicia el entorno de prueba de desarrollo local para tu agente:
    cd ~/secure-agent-lab/shopping-assistant
agents-cli playground
    Deberías ver un resultado que indica que el servidor de zona de pruebas local se está ejecutando en el puerto 8080:
    * Serving ADK Playground
* Running on http://127.0.0.1:8080/dev-ui/?app=app
  3. Abre la URL proporcionada en tu navegador web para comenzar a chatear con tu agente de Asistente de Compras de forma interactiva. Intenta pedirle que canjee un código de descuento:
    Can you redeem the discount code WELCOME50 for user user_123?
    El agente procesará tu solicitud con la ejecución del modelo de Gemini y tratará de canjear el descuento.

12. Limpia

Para limpiar tu estación de trabajo y evitar dejar recursos o secretos no deseados en tu entorno local, sigue estos pasos de limpieza.

  1. Detener servidor local: Si el servidor de Playground aún se está ejecutando, presiona Ctrl + C en la terminal para detenerlo.
  2. Remove Local Project Files: Borra el directorio del proyecto local de tu máquina: 
    rm -rf ~/secure-agent-lab

13. Felicitaciones

¡Felicitaciones! Estableciste correctamente un ciclo de vida de desarrollo seguro y basado en pruebas con el IDE de Google Antigravity, creaste un agente asistente de compras puro de ADK 2.0 y lo verificaste de forma local.

Qué aprendiste

  • Cómo crear la estructura e integrar un agente de ADK 2.0 (ADK) con el IDE de Antigravity y agents-cli
  • Cómo configurar estándares de programación seguros a nivel del proyecto con CONTEXT.md.
  • Cómo crear y ejecutar una habilidad personalizada de modelado de amenazas STRIDE en el IDE de Antigravity
  • Cómo restringir la fase de planificación de un agente de IA para aplicar límites de seguridad
  • Cómo implementar pruebas de seguridad aisladas y basadas en resultados con pytest
  • Cómo ejecutar y probar la aplicación basada en agentes de forma local
  • Las diferencias y las compensaciones entre los hooks de Git y los hooks de ejecución específicos del agente

Próximos pasos

Obtén tu insignia de Kaggle 5-Day AI Agents 🎉

¿Completaste este lab como parte del curso intensivo de vibe coding de 5 días con agentes de IA de Google de Kaggle? Reclama tu insignia de finalización:

Obtén la insignia de 5-Day AI Agents