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.

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:

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

Quick Reference: Pattern Selection

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