ClawHub

ADK Skill Patterns

MCP Tools

5 proven agent skill design patterns (Tool Wrapper, Generator, Reviewer, Inversion, Pipeline) from Google's ADK. Build reliable, composable skills with templates, decision trees, and composition guides. Stop cramming logic into prompts—use structured patterns instead.

Install

openclaw skills install adk-skill-patterns

ADK Skill Patterns 🧩

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.

PatternQuestion It AnswersUse 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:

CombinationEffect
Pipeline + ReviewerMulti-step workflow with quality gate at the end
Generator + InversionGather variables via interview, then fill template
Pipeline + Tool WrapperEach step loads specific expertise as needed
Reviewer + GeneratorReview output before generating final document

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

Quick Reference: Pattern Selection

ScenarioPatternWhy
"Teach my agent FastAPI conventions"Tool WrapperContext loads only when FastAPI mentioned
"Generate consistent API docs"GeneratorTemplate + style guide = predictable output
"Automate PR reviews"ReviewerSwap checklist for different audit types
"Plan a new project"InversionGathers full requirements before designing
"Generate docs from code"PipelineParse → 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

More in MCP Tools