# adk-skill-patterns

Adopt this skill: https://proskills.md/skills/other/maxlauriehutchinson-adk-skill-patterns

Page: https://proskills.md/skills/other/maxlauriehutchinson-adk-skill-patterns
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 7439
sha: fba9bc13559a8ef478f99d935886725d53eab4dd
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/SKILL.md

````text
---
name: adk-skill-patterns
description: 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.
metadata:
  openclaw:
    emoji: 🧩
  version: 1.0.0
---

# 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
````

## File: README.md
size: 7545
sha: 83be5763a7a87fa72553b7e4c76f40bc387a46ca
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/README.md

````text
# ADK Skill Patterns 🧩

[![ClawHub](https://img.shields.io/badge/ClawHub-adk--skill--patterns-blue)](https://clawhub.ai/skills/adk-skill-patterns)
[![Version](https://img.shields.io/badge/version-1.0.0-green)](https://github.com/MaxLaurieHutchinson/adk-skill-patterns/releases)
[![License](https://img.shields.io/badge/license-MIT-yellow)](LICENSE)

> 5 proven agent skill design patterns from Google's Agent Development Kit (ADK), adapted for the OpenClaw ecosystem.

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

---

## 🎯 The 5 Patterns

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

---

## 🚀 Quick Start

### Install via ClawHub
```bash
clawhub install adk-skill-patterns
```

### Use in OpenClaw
```
"Use the Tool Wrapper pattern to create a FastAPI expert skill"
"Apply the Pipeline pattern to my documentation workflow"
"Which pattern should I use for code review?"
```

---

## 📖 Pattern Details

### 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:** FastAPI conventions that load only when FastAPI is mentioned

```yaml
# SKILL.md
metadata:
  pattern: tool-wrapper
  domain: fastapi
```

---

### 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:** Standardized technical reports that follow exact structure every time

```yaml
# SKILL.md
metadata:
  pattern: generator
  output-format: markdown
```

---

### 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:** PR reviews, security scans, compliance audits

```yaml
# SKILL.md
metadata:
  pattern: reviewer
  severity-levels: error, warning, info
```

---

### 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:** Project planning, requirements gathering, system design

```yaml
# SKILL.md
metadata:
  pattern: inversion
  interaction: multi-turn
```

---

### 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:** Documentation generation, multi-step code workflows

```yaml
# SKILL.md
metadata:
  pattern: pipeline
  steps: "4"
```

---

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

---

## 🗺️ 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
```

---

## 📁 Repository Structure

```
adk-skill-patterns/
├── SKILL.md                              # Main skill documentation
├── README.md                             # This file
├── LICENSE                               # MIT License
├── CONTRIBUTING.md                       # Contribution guidelines
├── templates/                            # Ready-to-use SKILL.md templates
│   ├── tool-wrapper-SKILL.md
│   ├── generator-SKILL.md
│   ├── reviewer-SKILL.md
│   ├── inversion-SKILL.md
│   └── pipeline-SKILL.md
└── references/                           # Quick reference guides
    └── pattern-selection-checklist.md
```

---

## 🛠️ Creating a New Skill

1. **Choose a pattern** using the decision tree above
2. **Copy the template** from `templates/`
3. **Customize** the metadata and instructions
4. **Add references/assets** as needed
5. **Test** with real use cases
6. **Publish** to ClawHub

---

## 🎓 Best Practices

### Do ✅
- Use **Tool Wrapper** for domain-specific expertise
- Use **Generator** for any templated output
- Use **Reviewer** for quality gates
- Use **Inversion** for complex planning tasks
- Use **Pipeline** for multi-phase workflows
- **Compose patterns** for complex needs
- Keep `references/` modular and swappable

### Don't ❌
- Cram everything into system prompts (use Tool Wrapper)
- Accept inconsistent output (use Generator)
- Hardcode review criteria (use Reviewer)
- Let agents assume context (use Inversion)
- Allow skipped steps (use Pipeline)

---

## 📚 Resources

- **Source Article:** [Google Cloud Tech on X](https://x.com/GoogleCloudTech/status/2033953579824758855)
- **ADK Documentation:** [Google Agent Development Kit](https://google.github.io/adk-docs/)
- **ClawHub Page:** [adk-skill-patterns](https://clawhub.ai/skills/adk-skill-patterns)

---

## 🤝 Contributing

Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

### Ideas for contributions
- Additional pattern examples
- Real-world case studies
- Pattern compositions for common workflows
- Templates for other frameworks

---

## 📄 License

MIT License — see [LICENSE](LICENSE) for details.

---

## 🙏 Acknowledgments

- Original patterns from [Google Cloud Tech](https://x.com/GoogleCloudTech)
- Adapted for [OpenClaw](https://openclaw.ai) by [Max Laurie Hutchinson](https://github.com/MaxLaurieHutchinson)

---

**Build smarter agents. Use patterns, not prompts.** 🧩
````

## File: references/pattern-selection-checklist.md
size: 2586
sha: 1709bde928c25c328d3300191dda45345bbf0e2e
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/references/pattern-selection-checklist.md

````text
# Pattern Selection Checklist

## Quick Decision Matrix

| If the user wants to... | Use Pattern | File to Load |
|------------------------|-------------|--------------|
| Teach agent about a library | Tool Wrapper | `templates/tool-wrapper-SKILL.md` |
| Generate consistent documents | Generator | `templates/generator-SKILL.md` |
| Review/audit something | Reviewer | `templates/reviewer-SKILL.md` |
| Gather requirements first | Inversion | `templates/inversion-SKILL.md` |
| Multi-step workflow | Pipeline | `templates/pipeline-SKILL.md` |

## Pattern Combinations

### Common Compositions

**Documentation Pipeline (Pipeline + Generator + Reviewer)**
```
1. Parse code (Pipeline Step 1)
2. Generate docstrings (Generator)
3. Review quality (Reviewer)
4. Assemble final docs (Pipeline Step 4)
```

**Requirements → Plan (Inversion + Generator)**
```
1. Interview user for requirements (Inversion)
2. Fill plan template (Generator)
```

**Expert Review (Tool Wrapper + Reviewer)**
```
1. Load framework conventions (Tool Wrapper)
2. Review code against conventions (Reviewer)
```

## When to Use Each Pattern

### Tool Wrapper
✅ Agent needs deep knowledge about specific technology  
✅ Knowledge should only load when relevant  
✅ Multiple technologies need different expertise  
❌ General knowledge tasks  
❌ One-off queries

### Generator
✅ Output must be consistent every time  
✅ Template-based documents  
✅ Standardized formats (reports, docs, messages)  
❌ Creative/open-ended tasks  
❌ Exploratory work

### Reviewer
✅ Quality gates and audits  
✅ Modular criteria that may change  
✅ Consistent scoring/grading  
❌ Tasks without clear criteria  
❌ Subjective assessments

### Inversion
✅ Complex tasks requiring full context  
✅ Preventing premature solutions  
✅ Requirements gathering  
❌ Simple, well-defined tasks  
❌ When user already provided all context

### Pipeline
✅ Multi-phase workflows  
✅ Checkpoints requiring approval  
✅ Complex processes with dependencies  
❌ Single-step tasks  
❌ Exploratory/iterative work

## Anti-Pattern Detection

| Symptom | Likely Problem | Solution |
|---------|---------------|----------|
| Agent gives generic advice | Missing Tool Wrapper | Add domain-specific reference |
| Different output every time | Missing Generator | Create template + style guide |
| Inconsistent review quality | Missing Reviewer | Create modular checklist |
| Agent assumes requirements | Missing Inversion | Add structured interview |
| Steps get skipped | Missing Pipeline | Add explicit gates |
````

## File: CONTRIBUTING.md
size: 2669
sha: 417a034d08aabb42c392ab7b0a79a356079532a5
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/CONTRIBUTING.md

````text
# Contributing to ADK Skill Patterns

Thank you for your interest in contributing! This document provides guidelines for contributing to the ADK Skill Patterns project.

## How to Contribute

### Reporting Issues

If you find a bug or have a suggestion:

1. Check if the issue already exists in the [issue tracker](https://github.com/MaxLaurieHutchinson/adk-skill-patterns/issues)
2. If not, create a new issue with:
   - Clear title and description
   - Steps to reproduce (for bugs)
   - Expected vs actual behavior
   - Screenshots or examples if applicable

### Submitting Changes

1. **Fork** the repository
2. **Create a branch** for your changes (`git checkout -b feature/amazing-improvement`)
3. **Make your changes** following the guidelines below
4. **Test** your changes thoroughly
5. **Commit** with clear messages (`git commit -m 'Add: new pattern for X'`)
6. **Push** to your fork (`git push origin feature/amazing-improvement`)
7. **Open a Pull Request** with a detailed description

### Contribution Guidelines

#### For New Patterns

- Must solve a distinct problem not covered by existing patterns
- Include a clear use case and example
- Provide a working SKILL.md template
- Explain when NOT to use the pattern

#### For Pattern Examples

- Real-world use cases preferred
- Include complete, working SKILL.md
- Show before/after comparison if applicable

#### For Documentation

- Keep language clear and concise
- Use examples to illustrate concepts
- Update the decision tree if adding patterns

### Code Style

- Use YAML frontmatter for SKILL.md metadata
- Follow existing formatting in templates
- Use semantic line breaks in markdown
- Keep lines under 100 characters where possible

### Commit Message Format

```
Type: Brief description

Detailed explanation if needed.

- Bullet points for changes
- Reference issues: #123
```

Types:
- `Add:` New feature, pattern, or example
- `Fix:` Bug fix
- `Docs:` Documentation changes
- `Refactor:` Code restructuring
- `Test:` Adding tests

### Review Process

1. All contributions require review
2. Address feedback promptly
3. Keep discussions focused and constructive
4. Be respectful of reviewers' time

### Recognition

Contributors will be acknowledged in the README.md file.

## Questions?

- Open a [Discussion](https://github.com/MaxLaurieHutchinson/adk-skill-patterns/discussions)
- Contact via [ClawHub](https://clawhub.ai/skills/adk-skill-patterns)

## Code of Conduct

- Be respectful and inclusive
- Focus on constructive feedback
- Accept different viewpoints and experiences
- Prioritize community benefit

Thank you for helping make agent skills more reliable and composable! 🧩
````

## File: LICENSE
size: 1078
sha: 7dd0d7d7f58734b739611c1e75f4da526ae81f0b
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/LICENSE

```text
MIT License

Copyright (c) 2026 Max Laurie Hutchinson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

## File: templates/generator-SKILL.md
size: 1215
sha: dd381b36a2171909c74083b10456cf20efe92de9
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/templates/generator-SKILL.md

```text
# SKILL.md — Generator Pattern
# Pattern: Generator
# Use: Enforce consistent output via fill-in-the-blank orchestration

---
name: report-generator
description: Generates structured technical reports in Markdown. Use when the user asks to write, create, or draft a report, summary, or analysis document.

metadata:
  pattern: generator
  output-format: markdown
  version: 1.0
---

## Role
You are a technical report generator. Follow these steps exactly.

## Step 1: Load References
Load 'references/style-guide.md' for tone and formatting rules.

## Step 2: Load Template
Load 'assets/report-template.md' for the required output structure.

## Step 3: Gather Missing Information
Ask the user for any missing information needed to fill the template:
- Topic or subject
- Key findings or data points
- Target audience (technical, executive, general)
- Desired length/depth

## Step 4: Generate
Fill the template following the style guide rules.
Every section in the template must be present in the output.

## Step 5: Deliver
Return the completed report as a single Markdown document.

## Important
- Do NOT skip any template sections
- Maintain consistent formatting throughout
- Follow the style guide exactly
```

## File: templates/inversion-SKILL.md
size: 1727
sha: 060c6070b6c05f5d102b893ac6d6231f754e5fdf
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/templates/inversion-SKILL.md

```text
# SKILL.md — Inversion Pattern
# Pattern: Inversion
# Use: Agent interviews user before acting; stops premature generation

---
name: project-planner
description: Plans a new software project by gathering requirements through structured questions before producing a plan. Use when the user says "I want to build", "help me plan", "design a system", or "start a new project".

metadata:
  pattern: inversion
  interaction: multi-turn
  version: 1.0
---

## Role
You are conducting a structured requirements interview.

## CRITICAL INSTRUCTION
**DO NOT start building or designing until all phases are complete.**

## Phase 1 — Problem Discovery
Ask these questions ONE AT A TIME. Wait for each answer. Do not skip any.

- Q1: "What problem does this project solve for its users?"
- Q2: "Who are the primary users? What is their technical level?"
- Q3: "What is the expected scale? (users per day, data volume, request rate)"

## Phase 2 — Technical Constraints
Only proceed after Phase 1 is fully answered.

- Q4: "What deployment environment will you use?"
- Q5: "Do you have any technology stack requirements or preferences?"
- Q6: "What are the non-negotiable requirements? (latency, uptime, compliance, budget)"

## Phase 3 — Synthesis
Only proceed after ALL questions are answered.

1. Load 'assets/plan-template.md' for the output format
2. Fill in every section using the gathered requirements
3. Present the completed plan to the user
4. Ask: "Does this plan accurately capture your requirements? What would you change?"
5. Iterate on feedback until the user confirms

## Important
- Ask ONE question at a time
- Wait for user response before next question
- Do NOT synthesize early
- Gate each phase explicitly
```

## File: templates/pipeline-SKILL.md
size: 1818
sha: 94cd2c0f006f69027417de4fa582a6f74a59f6e9
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/templates/pipeline-SKILL.md

```text
# SKILL.md — Pipeline Pattern
# Pattern: Pipeline
# Use: Enforce strict sequential workflow with hard checkpoints

---
name: doc-pipeline
description: Generates API documentation from Python source code through a multi-step pipeline. Use when the user asks to document a module, generate API docs, or create documentation from code.

metadata:
  pattern: pipeline
  steps: "4"
  version: 1.0
---

## Role
You are running a documentation generation pipeline.

## CRITICAL INSTRUCTION
**Execute each step in order. Do NOT skip steps or proceed if a step fails.**

## Step 1 — Parse & Inventory
Analyze the user's Python code to extract:
- All public classes
- All public functions
- All public constants

Present the inventory as a checklist.
Ask: "Is this the complete public API you want documented?"

**GATE:** Do NOT proceed until user confirms.

## Step 2 — Generate Docstrings
For each function lacking a docstring:
1. Load 'references/docstring-style.md' for the required format
2. Generate a docstring following the style guide exactly
3. Present each generated docstring for user approval

**GATE:** Do NOT proceed to Step 3 until user confirms ALL docstrings.

## Step 3 — Assemble Documentation
1. Load 'assets/api-doc-template.md' for the output structure
2. Compile all classes, functions, and docstrings into a single API reference document

## Step 4 — Quality Check
Review against 'references/quality-checklist.md':
- Every public symbol documented
- Every parameter has a type and description
- At least one usage example per function

Report results. Fix issues before presenting final document.

## Important
- Execute steps sequentially
- Honor all gates — wait for explicit user confirmation
- Do not proceed if any step fails
- Keep context clean by only loading references when needed
```

## File: templates/reviewer-SKILL.md
size: 1448
sha: 6c42fd4a9d587a38467be3a67e72babb9381a330
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/templates/reviewer-SKILL.md

```text
# SKILL.md — Reviewer Pattern
# Pattern: Reviewer
# Use: Separate review criteria from review execution

---
name: code-reviewer
description: Reviews Python code for quality, style, and common bugs. Use when the user submits code for review, asks for feedback, or wants a code audit.

metadata:
  pattern: reviewer
  severity-levels: error, warning, info
  version: 1.0
---

## Role
You are a Python code reviewer. Follow this review protocol exactly.

## Step 1: Load Checklist
Load 'references/review-checklist.md' for the complete review criteria.

## Step 2: Understand Code
Read the user's code carefully. Understand its purpose before critiquing.

## Step 3: Apply Criteria
Apply each rule from the checklist to the code.

For every violation found:
- Note the line number (or approximate location)
- Classify severity:
  - **error**: must fix
  - **warning**: should fix
  - **info**: consider
- Explain WHY it's a problem, not just WHAT is wrong
- Suggest a specific fix with corrected code

## Step 4: Structure Output
Produce a structured review with these sections:

### Summary
What the code does, overall quality assessment

### Findings
Grouped by severity (errors first, then warnings, then info)

### Score
Rate 1-10 with brief justification

### Top 3 Recommendations
The most impactful improvements

## Important
- Check EVERY item in the checklist
- Be specific with line numbers
- Provide actionable fixes, not just criticism
```

## File: templates/tool-wrapper-SKILL.md
size: 1149
sha: a792387a339ed341fa4c59f5a23b99459e53f2b7
upstream: https://github.com/maxlauriehutchinson/adk-skill-patterns/blob/HEAD/templates/tool-wrapper-SKILL.md

```text
# SKILL.md — Tool Wrapper Pattern
# Pattern: Tool Wrapper
# Use: Give agent deep, contextual knowledge about a specific library/framework

---
name: api-expert
description: FastAPI development best practices and conventions. Use when building, reviewing, or debugging FastAPI applications, REST APIs, or Pydantic models.

metadata:
  pattern: tool-wrapper
  domain: fastapi
  version: 1.0
---

## Role
You are an expert in FastAPI development. Apply these conventions to the user's code or question.

## Core Conventions
Load 'references/conventions.md' for the complete list of FastAPI best practices.

## When Reviewing Code
1. Load the conventions reference
2. Check the user's code against each convention
3. For each violation, cite the specific rule and suggest the fix

## When Writing Code
1. Load the conventions reference
2. Follow every convention exactly
3. Add type annotations to all function signatures
4. Use Annotated style for dependency injection

## Important
- ONLY load conventions when FastAPI is explicitly mentioned
- Do not apply these rules to other frameworks
- Cite specific convention numbers when making suggestions
```
