From Anthropic to Google: Agent Skills Enter the Design‑Pattern Era

Background

Google Cloud Tech recently published an article titled “5 Agent Skill design patterns every ADK developer should know”. It classifies common Skills into five categories—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—while reflecting on the evolution of Agent Skills since Anthropic’s launch.

Why Skills Matter

Anthropic introduced Agent Skills in October 2023, solving the basic questions of how to organise the SKILL.md format, how the mechanism loads, and how Claude discovers them across products. The community has moved from asking “how to write the format” to “how to design the workflow”.

Five Design Patterns

Tool Wrapper : used when the Agent lacks domain knowledge (e.g., FastAPI, Terraform, Pandas). The Skill acts as an on‑demand domain manual, loading only when the user actually needs to write, review, or debug the technology.

Generator : solves unstable output formats. Templates live in assets/, style guides in references/, and SKILL.md coordinates loading, variable injection, and template filling.

Reviewer : separates the "how to review" process from the "what to review" checklist. The checklist is stored in references/review-checklist.md and the Skill enforces a consistent review flow.

Inversion : addresses premature generation. The Agent first acts as an interviewer, asking clarifying questions before proceeding to architecture design, deployment planning, or risk assessment.

Pipeline : prevents step‑skipping in complex tasks such as document generation, release, data migration, or incident post‑mortems. Checkpoints ensure each stage (discover, generate, confirm, assemble, quality‑check) is completed before moving on.

Each pattern corresponds to a common failure mode: missing domain knowledge, output drift, mixed review standards, unclear requirements, and skipped steps.

Tool Wrapper

When a library or framework is rarely used, placing its specification directly in the system prompt quickly bloats the context. Instead, wrap the knowledge in a Skill and load it only when the user explicitly needs to interact with that technology.

Generator

For tasks like reports, PR descriptions, or architecture docs where the structure must stay consistent, store the template in assets/ and let the Skill fill in variables. This separation of template and style makes maintenance far easier than embedding everything in a giant prompt.

Reviewer

Separate the review process (steps, order) from the review criteria (checklist). The Skill reads references/review-checklist.md, runs the checklist, grades the result, and suggests concrete fixes—mirroring traditional linting or static analysis pipelines.

Inversion

High‑risk or ambiguous tasks (e.g., system design, requirement analysis) should start with an interview phase. The Skill asks for scope, constraints, and environment before any design work begins, preventing the Agent from generating incomplete or unsafe solutions.

Pipeline

Complex multi‑step workflows need explicit checkpoints. For example, a documentation pipeline first parses a public API, asks the user to confirm the list, generates docstrings, then runs a quality checklist before publishing.

Skill vs. Harness

Harness runs the main loop: context stitching, tool invocation, state handling, error feedback, and permission gating. Skill provides the reusable, on‑demand modules that the harness loads—e.g., a Skill for API publishing, code review, or incident triage. In this view, a Skill is a process asset that the harness can plug into at runtime.

Practical Guidance for Teams

When introducing the first Skill, start with a narrow, high‑frequency workflow such as a fixed‑service release check, a framework‑specific code review, a data‑definition change review, an incident‑postmortem template, a pre‑merge security check, or a client‑solution information gather.

Ask six questions to define the Skill:

When should it trigger? (Use a precise description contract rather than a vague “help with deployment”.)

Which pattern does it belong to? (Tool Wrapper, Generator, Reviewer, Inversion, or Pipeline.)

What parts belong in references/, assets/, or scripts/?

Where are the necessary checkpoints?

How should failures be handled (detect, collect evidence, retry, ask a human, enforce limits)?

How will versioning and review be managed (owner, PR review, tests for high‑risk Skills, change logs, deprecation policy)?

Governance and Versioning

Treat Skills like code assets: assign an owner, require review for changes, add test cases for high‑risk Skills, keep a change log, regularly prune obsolete rules, and treat third‑party Skills as untrusted until audited.

From Prompt Writing to Workflow Design

The community has progressed from crafting single‑prompt sentences to engineering context, exposing tools, isolating sub‑agents, connecting MCP, and now formalising Skills as reusable workflow units. This shift marks a transition from “prompt engineering” to “process engineering” for AI agents.

References

Google Cloud Tech: “5 Agent Skill design patterns every ADK developer should know” – https://x.com/GoogleCloudTech/status/2033953579824758855

Claude official blog: Introducing Agent Skills – https://claude.com/blog/skills

Claude Code Docs: Extend Claude with skills – https://code.claude.com/docs/en/skills

Claude API Docs: Agent Skills – https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview

Anthropic PDF: The Complete Guide to Building Skills for Claude – https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf

Simon Willison: Claude Skills are awesome, maybe a bigger deal than MCP – https://simonwillison.net/2025/Oct/16/claude-skills/

Zak El Fassi: SkDD: Skills‑Driven Development – https://zakelfassi.com/skdd-skills-driven-development

Tobi Lütke on context engineering – https://x.com/tobi/status/1935533422589399127

Kaxil Naik on Claude Code, Skills, Hooks, MCP – https://x.com/kaxil/status/2037503513350005134