google-agents-cli-scaffold

Name: google-agents-cli-scaffold
Author: tomevault-io

AI Community

Repo stars 0
Author updated Live
Author repo skills-registry

Fluxly profile Facts only: domain, agents, trust score, runtime, permissions and network

Domain: AI
Compatible agents: Claude Code
Cursor
Cline
Codex
Windsurf
Gemini CLI

+20
Trust score: 88 / 100 · community maintained
Author / version / license: @tomevault-io · no license declared
Token usage: Lean
Setup complexity: Manual integration
External API key: Not required
Operating systems: Docker
Runtime requirements: Python · Docker
Permissions: Read-only
Write / modify
Shell exec
Env read
Network behavior: Local-only
Install commands: 26 variants

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview google-agents-cli-scaffold.preview

---
name: google-agents-cli-scaffold
description: > Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or…
category: ai
runtime: Python / Docker
---

# google-agents-cli-scaffold output preview

## PART A: Task fit
- Use case: > Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or enhance existing ones with deployment, CI/CD, and infrastructure scaffolding. runs entirely locally; runs on Python. Works with Claude Code, Cursor, Cline and 23 more..
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “Prerequisite: Clarify Requirements (MANDATORY for new projects) / Step 1: Choose Architecture / Product name mapping” and do not present inference as author intent.

## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “> Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or enhance existing ones with deployment, CI/CD, and infrastructure scaffolding. runs entirely locally; runs on Python. Works with Claude Code, Cursor, Cline and 23 more.”.
- **02** When the source has headings, the agent prioritizes “Prerequisite: Clarify Requirements (MANDATORY for new projects) / Step 1: Choose Architecture / Product name mapping” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files, run shell commands, read environment variables; mostly runs locally; usually needs no extra API key.

## Running Rules
- read files, write/modify files, run shell commands, read environment variables; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options.

SKILL.md SKILL.md

---
name: google-agents-cli-scaffold
description: > Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or…
category: ai
source: tomevault-io/skills-registry
---

# google-agents-cli-scaffold

## When to use
- > Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or enhance existing ones…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.

## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.

## Execution rules
- Organize steps around “Prerequisite: Clarify Requirements (MANDATORY for new projects) / Step 1: Choose Architecture / Product name mapping” and keep inference separate from source facts.
- read files, write/modify files, run shell commands, read environment variables; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding the task.

## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies.

Evidence boundary and execution chain

The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.

skill "google-agents-cli-scaffold" {
  input      -> user goal + target files + boundaries + acceptance criteria
  context    -> Prerequisite: Clarify Requirements (MANDATORY for new projects) / Step 1: Choose Architecture / Product name mapping
  rules      -> SKILL.md triggers / order / output contract
  runtime    -> Python / Docker | read files, write/modify files, run shell commands, read environment variables | mostly runs locally
  guardrails -> usually needs no extra API key + small-sample validation + diff/log review
  output     -> copyable result + checklist + next iteration
}

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: > Use when this capability is needed. Use the agents-cli CLI to create new ADK agent projects or enhance existing ones with depl…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “Prerequisite: Clarify Requirements (MANDATORY for new projects)”, “Step 1: Choose Architecture”, “Product name mapping”, “Step 2: Create or Enhance the Project”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name google-agents-cli-scaffold directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “Prerequisite: Clarify Requirements (MANDATORY for new projects) / Step 1: Choose Architecture / Product name mapping” before expanding.

Boundaries And Review

Dependencies: It usually needs no extra API key, so start with a small validation task.
Permissions: Declared permissions include read / write / shell-exec / env-read; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

ADK Project Scaffolding Guide

Requires: agents-cli (uv tool install google-agents-cli) — install uv first if needed.

Use the agents-cli CLI to create new ADK agent projects or enhance existing ones with deployment, CI/CD, and infrastructure scaffolding.

Prerequisite: Clarify Requirements (MANDATORY for new projects)

Before scaffolding a new project, load /google-agents-cli-workflow and complete Phase 0 — clarify the user's requirements before running any scaffold create command. Ask what the agent should do, what tools/APIs it needs, and whether they want a prototype or full deployment.

Step 1: Choose Architecture

Mapping user choices to CLI flags:

Choice	CLI flag
RAG with vector search	`--agent agentic_rag --datastore agent_platform_vector_search`
RAG with document search	`--agent agentic_rag --datastore agent_platform_search`
A2A protocol	`--agent adk_a2a`
Prototype (no deployment)	`--prototype`
Deployment target	`--deployment-target <agent_runtime\|cloud_run\|gke>`
CI/CD runner	`--cicd-runner <github_actions\|cloud_build>`
Session storage	`--session-type <in_memory\|cloud_sql\|agent_platform_sessions>`

Product name mapping

The platform formerly known as "Vertex AI" is now Gemini Enterprise Agent Platform (short: Agent Platform). Users may refer to products by different names. Map them to the correct CLI values:

User may say	CLI value
Agent Engine, Vertex AI Agent Engine, Agent Runtime	`--deployment-target agent_runtime`
Vertex AI Search, Agent Search	`--datastore agent_platform_search`
Vertex AI Vector Search, Vector Search	`--datastore agent_platform_vector_search`
Agent Engine sessions, Agent Platform Sessions	`--session-type agent_platform_sessions`

The vertexai Python SDK package name is unchanged.

Step 2: Create or Enhance the Project

Create a New Project

agents-cli scaffold create <project-name> \
  --agent <template> \
  --deployment-target <target> \
  --region <region> \
  --prototype

Constraints:

Project name must be 26 characters or less, lowercase letters, numbers, and hyphens only.
Do NOT mkdir the project directory before running create — the CLI creates it automatically. If you mkdir first, create will fail or behave unexpectedly.
Auto-detect the guidance filename based on the IDE you are running in and pass --agent-guidance-filename accordingly (GEMINI.md for Gemini CLI, CLAUDE.md for Claude Code, AGENTS.md for OpenAI Codex/other).
When enhancing an existing project, check where the agent code lives. If it's not in app/, pass --agent-directory <dir> (e.g. --agent-directory agent). Getting this wrong causes enhance to miss or misplace files.

Reference Files

File	Contents
`references/flags.md`	Full flag reference for `create` and `enhance` commands

Enhance an Existing Project

agents-cli scaffold enhance . --deployment-target <target>
agents-cli scaffold enhance . --cicd-runner <runner>

Run this from inside the project directory (or pass the path instead of .).

Upgrade a Project

Upgrade an existing project to a newer agents-cli version, intelligently applying updates while preserving your customizations:

agents-cli scaffold upgrade                # Upgrade current directory
agents-cli scaffold upgrade <project-path> # Upgrade specific project
agents-cli scaffold upgrade --dry-run      # Preview changes without applying
agents-cli scaffold upgrade --auto-approve  # Auto-apply non-conflicting changes

Execution Modes

The CLI defaults to strict programmatic mode — all required params must be supplied as CLI flags or a UsageError is raised. No approval flags needed. Pass all required params explicitly.

Common Workflows

Always ask the user before running these commands. Present the options (CI/CD runner, deployment target, etc.) and confirm before executing.

# Add deployment to an existing prototype (strict programmatic)
agents-cli scaffold enhance . --deployment-target agent_runtime

# Add CI/CD pipeline (ask: GitHub Actions or Cloud Build?)
agents-cli scaffold enhance . --cicd-runner github_actions

Template Options

Template	Deployment	Description
`adk`	Agent Runtime, Cloud Run, GKE	Standard ADK agent (default)
`adk_a2a`	Agent Runtime, Cloud Run, GKE	Agent-to-agent coordination (A2A protocol)
`agentic_rag`	Agent Runtime, Cloud Run, GKE	RAG with data ingestion pipeline

Deployment Options

Target	Description
`agent_runtime`	Managed by Google (Vertex AI Agent Runtime). Sessions handled automatically.
`cloud_run`	Container-based deployment. More control, requires Dockerfile.
`gke`	Container-based on GKE Autopilot. Full Kubernetes control.
`none`	No deployment scaffolding. Code only.

"Prototype First" Pattern (Recommended)

Start with --prototype to skip CI/CD and Terraform. Focus on getting the agent working first, then add deployment later with scaffold enhance:

# Step 1: Create a prototype
agents-cli scaffold create my-agent --agent adk --prototype

# Step 2: Iterate on the agent code...

# Step 3: Add deployment when ready
agents-cli scaffold enhance . --deployment-target agent_runtime

Agent Runtime and session_type

When using agent_runtime as the deployment target, Agent Runtime manages sessions internally. If your code sets a session_type`, clear it — Agent Runtime overrides it.

Step 3: Load Dev Workflow

After scaffolding, save DESIGN_SPEC.md to the project root if it isn't there already.

Then immediately load /google-agents-cli-workflow — it contains the development workflow, coding guidelines, and operational rules you must follow when implementing the agent.

Key files to customize: app/agent.py (instruction, tools, model), app/tools.py (custom tool functions), .env (project ID, location, API keys). Files to preserve: pyproject.toml [tool.agents-cli] section (CLI reads this), deployment configs under deployment/, Makefile, app/__init__.py (the App(name=...) must match the directory name — default app).

RAG projects (agentic_rag) — provision datastore first: Before running agents-cli playground or testing your RAG agent, you must provision the datastore and ingest data:

agents-cli infra datastore   # Provision datastore infrastructure
agents-cli data-ingestion    # Ingest data into the datastore

Use infra datastore — not infra single-project. Both provision the datastore, but infra datastore is faster because it skips unrelated Terraform. Without this step, the agent won't have data to search over.

Vector Search region: vector_search_location defaults to us-central1, separate from region (us-east1). It sets both the Vector Search collection region and the BQ ingestion dataset region, kept colocated to avoid cross-region data movement. Override per-invocation with agents-cli data-ingestion --vector-search-location <region>.

Verifying your agent works: Use agents-cli run "test prompt" for quick smoke tests, then agents-cli eval run for systematic validation. Do NOT write pytest tests that assert on LLM response content — that belongs in eval.

Scaffold as Reference

When you need specific files (Terraform, CI/CD workflows, Dockerfile) but don't want to scaffold the current project directly, create a temporary reference project in /tmp/:

agents-cli scaffold create /tmp/ref-project \
  --agent adk \
  --deployment-target cloud_run

Inspect the generated files, adapt what you need, and copy into the actual project. Delete the reference project when done.

This is useful for:

Non-standard project structures that enhance can't handle
Cherry-picking specific infrastructure files
Understanding what the CLI generates before committing to it

Critical Rules

NEVER skip requirements clarification — load /google-agents-cli-workflow Phase 0 and clarify the user's intent before running scaffold create
NEVER change the model in existing code unless explicitly asked
NEVER mkdir before create — the CLI creates the directory; pre-creating it causes enhance mode instead of create mode
NEVER create a Git repo or push to remote without asking — confirm repo name, public vs private, and whether the user wants it created at all
Always ask before choosing CI/CD runner — present GitHub Actions and Cloud Build as options, don't default silently
Agent Runtime clears session_type — if deploying to agent_runtime, remove any session_type setting from your code
Start with --prototype for quick iteration — add deployment later with enhance
Project names must be ≤26 characters, lowercase, letters/numbers/hyphens only
NEVER write A2A code from scratch — the A2A Python API surface (import paths, AgentCard schema, to_a2a() signature) is non-trivial and changes across versions. Always use --agent adk_a2a to scaffold A2A projects.

Examples

Using scaffold as reference: User says: "I need a Dockerfile for my non-standard project" Actions:

Create temp project: agents-cli scaffold create /tmp/ref --agent adk --deployment-target cloud_run
Copy relevant files (Dockerfile, etc.) from /tmp/ref
Delete temp project Result: Infrastructure files adapted to the actual project

A2A project: User says: "Build me a Python agent that exposes A2A and deploys to Cloud Run" Actions:

Follow the standard flow (understand requirements, choose architecture, scaffold)
agents-cli scaffold create my-a2a-agent --agent adk_a2a --deployment-target cloud_run --prototype Result: Valid A2A imports and Dockerfile — no manual A2A code written.

Troubleshooting

`agents-cli` command not found

See /google-agents-cli-workflow → Setup section.

/google-agents-cli-workflow — Development workflow, coding guidelines, and the build-evaluate-deploy lifecycle
/google-agents-cli-adk-code — ADK Python API quick reference for writing agent code
/google-agents-cli-deploy — Deployment targets, CI/CD pipelines, and production workflows
/google-agents-cli-eval — Evaluation methodology, evalset schema, and the eval-fix loop

Source: carlosmscabral/adk-agents-cabral — distributed by TomeVault.

Install command

One-click installPick a runner, click Copy, paste into your terminal, press enter

npx skills add tomevault-io/skills-registry/carlosmscabral--adk-agents-cabral--google-agents-cli-scaffold -y

Open general install guide

View skill source

Works with

Claude Code
Cursor
Cline
Codex
Windsurf
Gemini
OpenCode
Roo Code
AAide
+Augment
GitHub Copilot
OpenClaw
KKiro
Junie
WWarp
Goose
Trae
Kilo Code
OpenHands
Amp
Zencoder
CContinue
AIAider
CodeBuddy
CodeGeeX
Replit Agent

Security audit

88 / 100

Community

未声明 license/许可。
未声明 version。
未限定 allowed-tools，默认拥有全部工具权限。

Metadata

Source: github
tomevault-io/skills-registry
中文

More by @tomevault-io

Category & tags

Category AI