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. | 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