⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.0

adk-skill-patterns

maxlauriehutchinson@maxlauriehutchinson⭐ 1 stars· last commit 7mo ago· 0 open issues

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.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 1 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

ADK Skill Patterns 🧩

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

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

🚀 Quick Start

Install via ClawHub

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

# 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

# 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

# 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

# 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

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

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


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


🤝 Contributing

Contributions welcome! See 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 for details.


🙏 Acknowledgments


Build smarter agents. Use patterns, not prompts. 🧩

// HOW IT'S BUILT

// FILES

10 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md7.3 KBfba9bc13559aupstream ↗
    ---
    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
    
  • README.md7.4 KB83be5763a7a8upstream ↗
    # 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.** 🧩
    
  • references/pattern-selection-checklist.md2.5 KB1709bde928c2upstream ↗
    # 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 |
    
  • CONTRIBUTING.md2.6 KB417a034d08aaupstream ↗
    # 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! 🧩
    
  • LICENSE1.1 KB7dd0d7d7f587upstream ↗
    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.
    
  • templates/generator-SKILL.md1.2 KBdd381b36a217upstream ↗
    # 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
    
  • templates/inversion-SKILL.md1.7 KB060c6070b6c0upstream ↗
    # 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
    
  • templates/pipeline-SKILL.md1.8 KB94cd2c0f006fupstream ↗
    # 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
    
  • templates/reviewer-SKILL.md1.4 KB6c42fd4a9d58upstream ↗
    # 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
    
  • templates/tool-wrapper-SKILL.md1.1 KBa792387a339eupstream ↗
    # 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
    

Plain-text copy, no login: /skill-bundles/maxlauriehutchinson-adk-skill-patterns.md

// REPO STATS

1 stars
0 open issues
Last commit: 7mo ago