⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
adk-skill-patterns
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.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
ADK Skill Patterns 🧩
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
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 templatereferences/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:
| 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
- Choose a pattern using the decision tree above
- Copy the template from
templates/ - Customize the metadata and instructions
- Add references/assets as needed
- Test with real use cases
- 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
- ADK Documentation: Google Agent Development Kit
- ClawHub Page: adk-skill-patterns
🤝 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
- Original patterns from Google Cloud Tech
- Adapted for OpenClaw by Max Laurie Hutchinson
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, 2026README.md7.4 KB83be5763a7a8upstream ↗
# ADK Skill Patterns 🧩 [](https://clawhub.ai/skills/adk-skill-patterns) [](https://github.com/MaxLaurieHutchinson/adk-skill-patterns/releases) [](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 exactlytemplates/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 explicitlytemplates/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 neededtemplates/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 criticismtemplates/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