Google has released 5 Agent Skill design patterns.
These are 5 golden rules distilled by Google engineers after studying the entire Skill development ecosystem.
This article is a faithful translation of the original. Let's dive in:
When developers mention 𝚂𝙺𝙸𝙻𝙻.𝚖𝚍, they often focus on format: ensuring the YAML is correct, building directory structures, and following specifications.
However, with over 30 Agent tools (such as Claude Code, Gemini CLI, and Cursor) standardizing on the same layout, format issues have essentially become a thing of the past.
The real challenge now lies in content design.
While the specification explains how to package a Skill, it offers no guidance on how to construct the internal logic.
For example, a Skill wrapping FastAPI conventions operates quite differently from a four-step document processing pipeline, even though their 𝚂𝙺𝙸𝙻𝙻.𝚖𝚍 files look identical on the surface.
By studying how these Skills are built across the ecosystem—from Anthropic's repositories to Vercel and Google's internal guidelines—we've identified 5 recurring design patterns that help developers build better Agents.
Each pattern comes with runnable ADK (Agent Development Kit) code:
Tool Wrapper: Instantly makes your Agent an expert on any codebase
Generator: Produces structured documents from reusable templates
Reviewer: Scores code against a checklist based on severity
Inversion: The Agent interviews you before taking action
Pipeline: Enforces strict multi-step workflows with checkpoints
Pattern 1: The Tool Wrapper
The Tool Wrapper provides your Agent with on-demand context about a specific codebase.
Instead of hardcoding API conventions into a system prompt, you package them into a Skill. Your Agent only loads this context when actually using that technology.
This is the easiest pattern to implement. The 𝚂𝙺𝙸𝙻𝙻.𝚖𝚍 file listens for keywords about specific codebases in user prompts, dynamically loads your internal documentation from the 𝚛𝚎𝚏𝚎𝚛𝚎𝚗𝚌𝚎𝚜/ directory, and applies those rules as absolute truth.
This is the mechanism you use to distribute your team's internal coding guidelines or specific framework best practices directly into developer workflows.
Below is an example of a Tool Wrapper that teaches an Agent how to write FastAPI code. Note that the instructions explicitly tell the Agent to only load the 𝚌𝚘𝚗𝚟𝚎𝚗𝚝𝚒𝚘𝚗𝚜.𝚖𝚍 file when starting to review or write code:
Pattern 2: The Generator
While the Tool Wrapper focuses on applying knowledge, the Generator enforces consistent output.
If you're frustrated that your Agent produces different document structures every time, the Generator solves this through a carefully orchestrated "fill-in-the-blank" process.
It leverages two optional directories: 𝚊𝚜𝚜𝚎𝚝𝚜/ for your output templates, and 𝚛𝚎𝚏𝚎𝚛𝚎𝚗𝚌𝚎𝚜/ for style guides.
The instructions act as a project manager here. They tell the Agent to load templates, read style guides, ask the user for missing variables, and fill in the document.
This is highly practical for generating predictable API documentation, standardizing commit messages, or scaffolding project architecture.
In this technical report generator example, the Skill file itself doesn't contain actual formatting or syntax rules. It simply coordinates the retrieval of these assets and forces the Agent to execute them step by step:
Pattern 3: The Reviewer
The Reviewer pattern separates "what to check" from "how to check."
Instead of writing lengthy system prompts detailing every code smell, you store modular scoring criteria in a 𝚛𝚎𝚟𝚒𝚎𝚠-𝚌𝚑𝚎𝚌𝚔𝚕𝚒𝚜𝚝.𝚖𝚍 file.
When a user submits code, the Agent loads this checklist and systematically scores the submission, grouping its findings by severity level.
If you swap a Python code style checklist for an OWASP security checklist, you can use the exact same Skill infrastructure to get a completely different, highly specialized audit process.
This is a highly effective method for automating PR code reviews or catching vulnerabilities before a human ever looks at the code.
The code reviewer Skill below demonstrates this separation mechanism. The instructions remain static, but the Agent dynamically loads specific review criteria from an external checklist and forces a structured, severity-based output:
Pattern 4: Inversion
Agents often instinctively try to guess and generate results immediately.
The Inversion pattern flips this dynamic. Instead of the user driving the prompt and the Agent executing, the Agent plays the role of an interviewer.
The Inversion pattern relies on explicit, non-negotiable gating instructions (e.g., "Do not start building until all phases are complete") to force the Agent to gather context first.
It asks structured questions in sequence and waits for your answers before moving to the next stage.
Until it fully understands your requirements and deployment constraints, the Agent refuses to synthesize the final output.
To see this in action, check out the project planner Skill below. The key elements here are strict phase divisions and explicit gating prompts that prevent the Agent from synthesizing a final plan before collecting all user responses:
Pattern 5: The Pipeline
For complex tasks, you can't afford to miss steps or ignore instructions.
The Pipeline pattern enforces a strictly sequential workflow with hard checkpoints.
The instructions themselves serve as the workflow definition. By implementing explicit diamond gate conditions (e.g., requiring user approval before proceeding from docstring generation to final assembly), the pipeline ensures the Agent cannot bypass complex tasks and produce an unverified final result.
This pattern utilizes all optional directories, pulling in relevant reference files and templates only at the specific steps where they're needed, keeping the context window clean.
In this document processing pipeline example, notice the explicit gate conditions. We explicitly forbid the Agent from entering the assembly phase unless the user first confirms the docstrings generated in the previous step:
Each pattern solves different problems. Use the decision tree below to find the right pattern for your use case:
These patterns are not mutually exclusive. They can be combined.
A Pipeline Skill can include a Reviewer step at the end to double-check its own work.
A Generator can rely on the Inversion pattern at the start to collect necessary variables before filling its templates.
Thanks to ADK's 𝚂𝚔𝚒𝚕𝚕𝚃𝚘𝚘𝚕𝚜𝚎𝚝 and progressive disclosure mechanism, your Agent only consumes context tokens at runtime for the specific patterns it actually needs.
Stop trying to cram complex, fragile instructions into a single system prompt.
Split your workflow, apply the right design patterns, and build reliable Agents.
The Agent Skills specification is open source and natively supported across the entire ADK ecosystem.
You've learned how to package the format. Now you've mastered how to design the content. Go build smarter Agents with the Google Agent Development Kit.
Reference:
https://x.com/GoogleCloudTech/article/2033953579824758855
END