Vibecode e proteção do ciclo de vida de um agente de IA com Antigravity e TDD

1. Introdução

Neste codelab, você vai criar um aplicativo da Web de varejo com um assistente de compras de IA integrado usando o Kit de Desenvolvimento de Agente (ADK) do Google. Você vai usar o IDE do Google Antigravity (IDE agêntico do Google) para estabelecer um fluxo de trabalho de desenvolvimento orientado a testes (TDD) seguro.

Em vez de tratar a segurança como um portão de estágio final, você vai aprender a "mudar a segurança para a esquerda" até o ponto de início do código. Você vai aplicar padrões de desenvolvimento, automatizar a modelagem de ameaças STRIDE e controlar as ações do agente com hooks de pré-commit do Git e hooks de execução específicos do agente.

Atividades deste laboratório

  • Estruturar e criar um agente assistente de compras do ADK 2.0 usando o IDE do Antigravity e o agents-cli.
  • Configure padrões de programação segura para envolvidos no projeto usando um arquivo de contexto persistente (CONTEXT.md).
  • Criar e invocar uma habilidade personalizada de modelagem de ameaças STRIDE no nível do espaço de trabalho no IDE do Antigravity.
  • Aplique proteções de segurança diretamente durante a fase de planejamento do TDD.
  • Escrever testes de segurança baseados em resultados no Pytest usando o Antigravity.
  • Configure hooks de pré-commit do Git para automatizar verificações do Semgrep com loops de correção locais no Antigravity.

O que é necessário

  • Um navegador da web, como o Chrome
  • Familiaridade com Python, Pytest e comandos básicos de terminal
  • IDE do Google Antigravity instalada. Consulte o site oficial.
  • O gerenciador de pacotes uv instalado. Consulte o guia de instalação do uv.
  • A ferramenta de linha de comando Git instalada. O Git é usado exclusivamente para controle de versões local neste laboratório, então não é necessário ter uma conta do GitHub. Consulte o guia de instalação do Git.

Este codelab é destinado a desenvolvedores de todos os níveis, inclusive iniciantes. O laboratório inteiro leva aproximadamente 60 minutos para ser concluído.

Configurar a autenticação e o ambiente

Forneça suas credenciais de autenticação para que o agente possa chamar os modelos do Gemini. Consiga uma chave de API Gemini padrão no Google AI Studio e exporte-a na sessão do terminal do IDE:

export GEMINI_API_KEY="your_api_key_here"
export GOOGLE_GENAI_USE_ENTERPRISE=FALSE

2. Configurar o espaço de trabalho e a cadeia de ferramentas

Primeiro, inicialize o espaço de trabalho do projeto e instale a cadeia de ferramentas de gerenciamento de agentes. Para isso, vamos pedir ao Antigravity IDE que automatize o processo de configuração.

👉 Comando para o 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`.

O que esperar:o Antigravity vai executar os comandos de terminal necessários em seu nome, estabelecendo um repositório Git limpo e instalando as habilidades complementares do ADK no seu ambiente de desenvolvimento integrado.

3. Estruturar o projeto do agente do ADK

Nesta fase, orientamos o Antigravity a usar o agents-cli para criar um projeto de agente do ADK 2.0 totalmente funcional chamado shopping-assistant. Vamos instruir o Antigravity a criar um assistente de varejo com uma ferramenta de resgate de descontos.

Observação:para mostrar o poder dos hooks de gating automatizados, nesta solicitação, instruímos explicitamente o Antigravity a incluir uma vulnerabilidade simulada: uma chave de API simulada codificada usada para desenvolvimento local.

👉 Comando para o 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"`.

O que esperar:o Antigravity vai executar agents-cli scaffold create shopping-assistant --adk, configurar pyproject.toml e implementar a lógica do agente.

4. Conheça o código do agente

👉 Peça para o Antigravity explicar o código gerado:

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.

Na IDE do Antigravity, os arquivos de projeto recém-criados são exibidos diretamente no painel auxiliar (lado esquerdo). Você pode ver shopping-assistant/app/agent.py lá ou abrir no explorador de arquivos do ambiente de desenvolvimento integrado.

# 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ática recomendada de produção: simultaneidade e condições de disputa

Na lógica da ferramenta, verificamos um dicionário na memória (DISCOUNT_STORE) e modificamos o estado dele. Em um ambiente de produção multithread com um banco de dados real, duas solicitações simultâneas podem ler o código como não resgatado antes de qualquer confirmação de gravação, causando uma vulnerabilidade de resgate duplo. Em produção, sempre use bloqueio pessimista (por exemplo, .with_for_update()) ou controle de versões otimista para garantir o isolamento da transação.

Fazer lint do gráfico de agentes inicial

Para verificar se o gráfico do agente recém-estruturado é compilado corretamente, podemos pedir ao Antigravity para executar o linter e testar o agente em nosso nome.

👉 Comando para o Antigravity:

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

O que esperar:o Antigravity vai executar agents-cli lint e agents-cli lint --fix para corrigir problemas de formatação ou de lint detectados.

5. Criar regras específicas do projeto

Para evitar sobrecarregar a memória ativa do seu agente com milhares de páginas de documentação de segurança genérica, o que causa deterioração do contexto e latência de raciocínio, é necessário estabelecer um "caminho pavimentado" de convenções seguras pré-aprovadas. No IDE do Antigravity, é possível estabelecer essas restrições criando um arquivo de contexto persistente.

👉 Comando para o 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.

O que esperar:o Antigravity vai criar o diretório .agents/ e o arquivo CONTEXT.md, mostrando-os diretamente no painel auxiliar para sua revisão.

6. Configurar hooks de gating locais

Para evitar que códigos ou segredos não seguros saiam da sua estação de trabalho, configure gates automatizados nos limites do ambiente de desenvolvimento antes de confirmar o código. Vamos pedir para o Antigravity gerar as configurações de hook e depois instalá-las usando o terminal.

1. Hook de pré-confirmação do Git

Para garantir que nossa análise estática detecte de forma confiável credenciais simuladas e bloqueie commits não seguros, vamos definir uma regra personalizada do Semgrep e configurar um hook de pré-commit do Git para aplicá-la.

Definir uma regra personalizada do Semgrep

As regras padrão do Semgrep (--config auto) não sinalizam chaves simuladas que contêm palavras como "mock" ou hífens devido à baixa pontuação de confiança. Para detectar de maneira confiável nossa chave de API codificada, vamos criar um arquivo de regras local personalizado usando a verificação direta de regex em vez de regras genéricas.

👉 Comando para o 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.

O que esperar:o Antigravity vai criar shopping-assistant/.semgrep/rules.yaml definindo nossa regra de verificação personalizada. Revise a definição de regra gerada:

# 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

Configurar o hook de pré-commit

Em seguida, configure o hook de pré-commit do Git para executar nossa regra personalizada do Semgrep. Ao executar hooks em um layout de subdiretório, os caminhos para as configurações locais precisam ser relativos ao diretório raiz do repositório Git (shopping-assistant/.semgrep/rules.yaml), não ao subdiretório do projeto.

👉 Comando para o 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.

O que esperar:o Antigravity vai gerar shopping-assistant/.pre-commit-config.yaml e executar pre-commit install em seu nome. Revise a configuração gerada:

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

Essa configuração garante que, mesmo que um agente esteja sendo executado no modo totalmente autônomo e não interativo, o gate de pré-commit será acionado e bloqueará qualquer commit que falhe nas verificações de análise estática.

Comandos de execução direta (para verificação manual)

Para verificar manualmente a configuração da análise estática sem acionar um ciclo completo de hook de commit, execute estas verificações diretamente do terminal.

Via pre-commit (do diretório "shopping-assistant"):

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

Diretamente pelo Semgrep (no diretório "shopping-assistant"):

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

2. Hook do agente do Antigravity integrado

Para um controle mais profundo e no meio da trajetória, configure um hook de agente em shopping-assistant/.agents/hooks.json. Ao contrário dos hooks do git, os hooks do agente interceptam o Antigravity antes que ele possa executar ferramentas críticas (como comandos do shell) no seu sistema.

👉 Comando para o 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.

O que esperar:o Antigravity vai criar shopping-assistant/.agents/hooks.json. Revise a configuração gerada:

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

Em seguida, peça para o Antigravity criar o script de validação da ferramenta subjacente referenciado pelo nosso hook.

👉 Comando para o 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 /`.

O que esperar:o Antigravity vai gerar shopping-assistant/.agents/scripts/validate_tool_call.py, semelhante ao exemplo abaixo. Revise o script de validação gerado:

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

Compensações de hook

  • Hooks do Git: nativos do controle de versão; são executados mesmo que um agente seja executado no modo totalmente autônomo e não interativo. No entanto, é possível ignorá-los usando a flag --no-verify durante um commit.
  • Hooks de agente: capturam eventos no meio da trajetória para bloquear comandos de ferramentas perigosos, mas não protegem o repositório se um desenvolvedor ignorar o IDE.

Os gates locais reforçam bons hábitos de desenvolvimento e ajudam a detectar vulnerabilidades instantaneamente. No entanto, os gates locais podem ser ignorados. Isso significa que seu pipeline de CI/CD remoto e isolado continua sendo a barreira de segurança final e intransponível.

7. Implementar a habilidade de modelagem de ameaças STRIDE

Agora, você vai conceder à Antigravity o conhecimento especializado de um arquiteto de segurança. As habilidades de Antigravity são diretórios modulares e declarativos do Markdown que instruem o agente a executar jobs de raciocínio em várias etapas. O Antigravity descobre automaticamente todas as habilidades colocadas em .agents/skills/.

👉 Comando para o 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.

O que esperar:o Antigravity vai criar o diretório de habilidades personalizadas e o arquivo SKILL.md.

Agora, vamos executar a habilidade recém-criada para avaliar o gráfico do projeto ativo (shopping-assistant/app/agent.py).

👉 Comando para o Antigravity:

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

O que esperar:o Antigravity corresponde à sua intenção, carrega as instruções de avaliação de ameaças sob demanda do diretório de habilidades local, analisa seu arquivo agent.py atual e gera um threat_model.md estruturado diretamente na raiz shopping-assistant. Essa abordagem mantém seu contexto de trabalho diário limpo e leve, além de oferecer acesso instantâneo ao raciocínio de segurança especializado.

8. Controlar a fase de planejamento do TDD

Antes de implementar mais recursos ou refatorar o código, o Antigravity usa a compreensão semântica da base de código para mapear as mudanças em uma lista de verificação implementation_plan.md e task.md. Para forçar o Antigravity a projetar para segurança desde o início, configuramos uma regra do sistema em .agents/CONTEXT.md que restringe a aprovação do plano.

👉 Comando para o 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.

O que esperar:o Antigravity vai atualizar shopping-assistant/.agents/CONTEXT.md com a nova regra de validação de planejamento.

Quando você pedir para a Antigravidade criar ou refatorar um recurso nas etapas seguintes, ela vai analisar automaticamente essa regra e apresentar um plano de implementação com um detalhamento explícito de segurança. Você pode revisar esse plano diretamente na caixa de diálogo interativa ou no painel auxiliar do Antigravity. Clique em Continuar ou Aprovar antes de começar a geração de código.

Testar o portão de planejamento (opcional)

Para observar esse portão de planejamento em ação agora, peça ao Antigravity um dos seguintes recursos. Em vez de gerar código imediatamente, o Antigravity entra na fase de planejamento e apresenta um implementation_plan.md com um detalhamento de Limites e declarações de segurança (por exemplo, identificando condições de corrida, escalonamento de privilégios não autorizado ou valores de pontos negativos) para sua análise.

👉 Comando para o Antigravity (escolha um para testar):

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. Escrever testes isolados e baseados em resultados

Agora vamos orientar a Antigravity a escrever testes de segurança abrangentes para nossas ferramentas de agente do ADK atuais. Para garantir que nossos testes de segurança sejam resilientes e realistas, estruturamos eles com base em dois princípios principais:

  • Faça asserções sobre resultados, não interações: faça asserções sobre strings de retorno final e mutações de estado em vez de escrever mocks frágeis que espionam chamadas de helper internas.
  • Impor restrições rígidas: verifique se as ferramentas impõem limites explícitos de lógica de negócios (como regras de resgate de uso único e de usuários registrados).

👉 Comando para o 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.

O que esperar:o Antigravity vai gerar shopping-assistant/tests/test_agent.py, semelhante ao exemplo abaixo. Revise o arquivo de teste gerado:

# 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

Verificar a fase VERDE do TDD

Para verificar se os testes de segurança recém-gerados são aprovados na nossa implementação agent.py atual, peça ao Antigravity para executar o pytest em seu nome.

👉 Comando para o Antigravity:

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

O que esperar:o Antigravity vai executar uv run pytest tests/test_agent.py no terminal. Todos os casos de teste são aprovados. Os limites lógicos do aplicativo agora estão seguros, mas precisamos garantir que nosso scanner estático detecte a chave de API codificada durante o commit.

10. Verificar o controle de acesso e a autocorreção do agente

Agora que os testes estão verdes, você entra na Fase de refatoração e commit. É aqui que nossas verificações de segurança locais e hooks de pré-commit verificam se nenhum repositório sai da estação de trabalho com vulnerabilidades, e o Antigravity demonstra suas capacidades autônomas de autocorreção.

  1. No terminal, navegue até o diretório do projeto e faça o commit do código usando uv run para garantir que os binários do hook de pré-commit local estejam ativos no seu PATH:
    cd ~/secure-agent-lab/shopping-assistant
git add .
uv run git commit -m "feat: implement shopping assistant agent"
  2. O commit falha porque o hook de pré-commit do Git executa o Semgrep automaticamente:
    Semgrep Security Scan....................................................Failed
- hookid: semgrep

  app/agent.py
  Security Issue: Hardcoded Google API key prefix detected.
  3. Com base na regra Pre-Commit Remediation Loop configurada em .agents/CONTEXT.md, o Antigravity intercepta automaticamente a falha de pré-commit no terminal do IDE, lê os registros de erros do Semgrep e inicia uma etapa de refatoração para migrar de uma chave de API codificada para a recuperação segura da chave.
  4. Revise o código refatorado gerado pelo Antigravity em shopping-assistant/app/agent.py para resolver o vazamento da chave de API.
  5. O Antigravity executa automaticamente pytest para verificar se os testes ainda estão verdes.
  6. O Antigravity tenta fazer o commit novamente em seu nome. Se a identidade do Git local estiver configurada e um repositório inicializado, a verificação será aprovada e o commit será concluído.

Isso demonstra o poder principal de combinar TDD com hooks de pré-commit locais e loops de agente. Em vez de esperar uma falha remota de CI/CD, o agente é mantido responsável localmente, refatorando o código para ser seguro por padrão antes de ser enviado.

11. Executar e testar o agente localmente

Agora que os limites de segurança foram verificados e confirmados, execute o agente do ADK localmente usando a chave de API Gemini exportada para interagir com ele no playground local.

  1. No terminal, verifique se a chave da API Gemini foi exportada no seu ambiente:
    echo $GEMINI_API_KEY # Verify your key is exported
  2. Inicie o playground de desenvolvimento local para seu agente:
    cd ~/secure-agent-lab/shopping-assistant
agents-cli playground
    Você vai ver uma saída indicando que o servidor local do playground está sendo executado na porta 8080:
    * Serving ADK Playground
* Running on http://127.0.0.1:8080/dev-ui/?app=app
  3. Abra o URL fornecido no navegador da Web para começar a conversar com o agente do Assistente de compras de forma interativa. Tente pedir para ele resgatar um código de desconto:
    Can you redeem the discount code WELCOME50 for user user_123?
    O agente vai processar sua solicitação usando a execução do modelo do Gemini e tentar resgatar o desconto.

12. Limpar

Para limpar sua estação de trabalho e evitar deixar recursos ou segredos indesejados no ambiente local, siga estas etapas de limpeza.

  1. Interrompa o servidor local: se o servidor do playground ainda estiver em execução, interrompa-o no terminal pressionando Ctrl + C.
  2. Remover arquivos do projeto local: exclua o diretório do projeto local da sua máquina: 
    rm -rf ~/secure-agent-lab

13. Parabéns

Parabéns! Você estabeleceu um ciclo de vida de desenvolvimento seguro e orientado por testes usando a IDE do Google Antigravity, criou um agente assistente de compras puro do ADK 2.0 e o verificou localmente.

O que você aprendeu

  • Como criar e integrar um agente do ADK 2.0 (ADK) usando a IDE do Antigravity e o agents-cli.
  • Como configurar padrões de programação segura para envolvidos no projeto usando CONTEXT.md.
  • Como criar e executar uma habilidade personalizada de modelagem de ameaças STRIDE no IDE do Antigravity.
  • Como restringir a fase de planejamento de um agente de IA para aplicar limites de segurança.
  • Como implementar testes de segurança isolados e baseados em resultados usando o pytest.
  • Como executar e testar o aplicativo de agente localmente.
  • As diferenças e compensações entre hooks do Git e hooks de execução específicos do agente.

Próximas etapas

Receba seu selo de 5 dias de agentes de IA do Kaggle 🎉

Você concluiu este laboratório como parte do Curso intensivo de vibe coding de 5 dias sobre agentes de IA com o Google do Kaggle? Resgate seu selo de conclusão:

Receba o selo de 5 dias de agentes de IA