ADK Skill Patterns

5 proven agent skill design patterns (Tool Wrapper, Generator, Reviewer, Inversion, Pipeline) from Google's ADK. Build reliable, composable skills with templ...

Security Scan

Instruction-only skill that provides reusable agent design patterns and templates; its files, instructions, and required capabilities are coherent and proportionate to the stated purpose.

Purpose & Capability

The skill advertises five ADK patterns and only includes documentation and templates to implement those patterns. It requests no binaries, env vars, or installs, which is appropriate for a patterns/templates guide.

Instruction Scope

SKILL.md and the templates instruct the agent to load local references, ask the user questions, and read user-supplied code when relevant. Those actions are consistent with a patterns/templates repo; there are no instructions to read unrelated system files, access external endpoints, or exfiltrate data.

Install Mechanism

No install specification or code files are present. Being instruction-only means nothing is downloaded or written to disk by the skill itself, which minimizes installation risk.

Credentials

The skill declares no required environment variables, credentials, or config paths. The templates reference only local files inside the skill (references/, assets/, templates/), which matches the described functionality.

Persistence & Privilege

always is false and there is no mechanism to self-enable or persist across agents. The skill does not request elevated privileges or modify other skills or system-wide settings.

Assessment

This is an instruction-only templates/guide pack for designing agent skills and appears coherent and low-risk. Before installing, review the included templates and checklist to ensure they match your intended workflows. Note the skill will read user-supplied code or prompts when invoked (expected for Reviewer/Pipeline patterns) — avoid sending sensitive secrets or credentials to the skill. Because it has no install steps or external endpoints, its primary risk is accidental disclosure of data you feed into it, not background exfiltration. If you plan to let agents invoke skills autonomously, remember autonomous invocation is allowed by default; consider disabling autonomous invocation if you want manual control.

Source: Google Cloud Tech — 5 Agent Skill Design Patterns
Adapted for: OpenClaw Agent System
Purpose: Build reliable, composable agent skills using proven architectural patterns

---

Overview

The specification explains how to package a skill, but offers zero guidance on how to structure the logic inside it. These 5 patterns solve that problem.

Pattern	Question It Answers	Use When
Tool Wrapper	"How do I make my agent an expert on a specific library?"	Agent needs deep, contextual knowledge about a technology
Generator	"How do I enforce consistent output structure?"	Output format must be predictable every time
Reviewer	"How do I separate what to check from how to check it?"	Code review, quality gates, compliance checking
Inversion	"How do I stop the agent from guessing and gather requirements first?"	Complex tasks requiring full context before execution
Pipeline	"How do I enforce a strict multi-step workflow?"	Multi-phase tasks with checkpoints and approvals

---

Pattern 1: Tool Wrapper

Purpose: Give your agent on-demand context for a specific library/framework.

Mechanism:

• Listens for library keywords in prompts
• Dynamically loads documentation from references/
• Applies conventions as absolute truth only when needed

Example Use Cases:

• FastAPI conventions
• Internal coding standards
• Framework-specific best practices
• API design guidelines

Template: See templates/tool-wrapper-SKILL.md

---

Pattern 2: Generator

Purpose: Enforce consistent output via fill-in-the-blank orchestration.

Mechanism:

• assets/ holds output template
• references/ holds style guide
• Instructions act as project manager
• Asks for missing variables before generating

Example Use Cases:

• API documentation generation
• Standardized commit messages
• Project scaffolding
• Technical reports

Template: See templates/generator-SKILL.md

---

Pattern 3: Reviewer

Purpose: Separate review criteria from review execution.

Mechanism:

• Stores modular rubric in references/review-checklist.md
• Methodically scores submissions
• Groups findings by severity
• Swap checklist = completely different audit

Example Use Cases:

• PR review automation
• Security vulnerability scanning
• Code quality audits
• Compliance checking

Template: See templates/reviewer-SKILL.md

---

Pattern 4: Inversion

Purpose: Stop agents from guessing — make them interview first.

Mechanism:

• Agent acts as interviewer, not executor
• Structured questions in phases
• Hard gates prevent premature synthesis
• User drives through answers, not prompts

Example Use Cases:

• Project planning/requirements gathering
• System design interviews
• Complex task specification
• Knowledge extraction

Template: See templates/inversion-SKILL.md

---

Pattern 5: Pipeline

Purpose: Enforce strict sequential workflow with hard checkpoints.

Mechanism:

• Instructions = workflow definition
• Diamond gate conditions (user approval required)
• Cannot bypass steps or present unvalidated results
• Progressive disclosure keeps context clean

Example Use Cases:

• Documentation generation workflows
• Multi-step code generation
• Complex build/deploy pipelines
• Research synthesis workflows

Template: See templates/pipeline-SKILL.md

---

Decision Tree

START: What does your skill need to do?
│
├─→ Provide deep knowledge about a specific library/framework?
│   └─→ Use: TOOL WRAPPER
│
├─→ Produce consistent, templated output?
│   └─→ Use: GENERATOR
│
├─→ Check/audit something against criteria?
│   └─→ Use: REVIEWER
│
├─→ Gather requirements before acting?
│   └─→ Use: INVERSION
│
├─→ Execute strict multi-step workflow?
│   └─→ Use: PIPELINE
│
└─→ Multiple of the above?
    └─→ Patterns COMPOSE (see below)

---

Pattern Composition

These patterns are not mutually exclusive — they compose:

Combination	Effect
Pipeline + Reviewer	Multi-step workflow with quality gate at the end
Generator + Inversion	Gather variables via interview, then fill template
Pipeline + Tool Wrapper	Each step loads specific expertise as needed
Reviewer + Generator	Review output before generating final document

Principle: Your agent only spends context tokens on the exact patterns it needs at runtime.

---

Quick Reference: Pattern Selection

Scenario	Pattern	Why
"Teach my agent FastAPI conventions"	Tool Wrapper	Context loads only when FastAPI mentioned
"Generate consistent API docs"	Generator	Template + style guide = predictable output
"Automate PR reviews"	Reviewer	Swap checklist for different audit types
"Plan a new project"	Inversion	Gathers full requirements before designing
"Generate docs from code"	Pipeline	Parse → Generate → Review → Assemble

---

Directory Structure

skills/
└── your-skill/
    ├── SKILL.md              # Instructions (implements pattern)
    ├── references/           # Knowledge, checklists, style guides
    │   ├── conventions.md
    │   ├── review-checklist.md
    │   └── style-guide.md
    └── assets/               # Templates, examples
        ├── report-template.md
        └── plan-template.md

---

Anti-Patterns to Avoid

❌ Cramming everything into system prompt — Use Tool Wrapper instead
❌ Different output every run — Use Generator for consistency
❌ Hardcoded review criteria — Use Reviewer for modularity
❌ Agent assumes context — Use Inversion to gather requirements
❌ Skipped steps in workflows — Use Pipeline for enforcement

---

Implementation Notes for OpenClaw

1. File Loading: Use read tool to load references/assets dynamically
2. Pattern Detection: Check user's intent to determine which pattern to apply
3. Composition: Chain skills via sessions_spawn for complex workflows
4. Gates: Explicit user confirmation before proceeding (especially Pipeline/Inversion)

---

Using This Skill

To Apply a Pattern

Ask me: "Use the [pattern-name] pattern to [task]"

Examples:

• "Use the Tool Wrapper pattern to create a FastAPI expert skill"
• "Use the Generator pattern to standardize my report outputs"
• "Use the Reviewer pattern to build a code quality checker"
• "Use the Inversion pattern to plan my new project"
• "Use the Pipeline pattern to create a documentation workflow"

To Get Pattern Advice

Ask: "Which pattern should I use for [scenario]?"

To Compose Patterns

Ask: "How do I combine [pattern-1] and [pattern-2]?"

---

Source Article: https://x.com/GoogleCloudTech/status/2033953579824758855
Last Updated: March 29, 2026