Google Bets on Agent Skills: The Format Winning the De-Facto Standard War

TL;DR

Through the second half of 2025, a particular kind of repository kept surfacing on GitHub Trending: anthropics/skills, mattpocock/skills, addyosmani/agent-skills, and most recently google/skills. They are all building ecosystems around the same format—Agent Skills. Google's official entry is especially worth paying attention to: a 17,000+ star repository that packages knowledge of 80+ Google products—GKE, BigQuery, AlloyDB, Gemini API—into skills that any coding agent can load.

This is not yet another prompt template library. This is the de-facto standardization of a knowledge packaging format—a cross-vendor format proposed by Anthropic, endorsed by Google, and already supported by 30+ mainstream clients. This article breaks it down from seven angles.

I. The Origins of the Agent Skills Format: How Anthropic Proposed It

From "System Prompts" to "Loadable Skill Packages"

The core insight behind Agent Skills is straightforward: LLMs are general-purpose, but real tasks demand domain knowledge.

The early solution was to pile instructions into the system prompt—cramming everything into one giant context window. This approach has three fatal flaws:

The context window is finite—once full, it crowds out the space for reasoning;
All instructions are present at once—the model must decide which instruction is relevant to the current task, and it often goes astray;
It's not reusable—switch projects and you rewrite everything.

Anthropic's answer is Progressive Disclosure: encapsulate domain knowledge into independent "skill" units. Normally only a minimal index is exposed (name + description, roughly 100 tokens). Only when the agent determines that the current task matches a skill does it load the full instructions.

Spec Definition

The official spec is now hosted at agentskills.io/specification, with the repository at anthropics/skills (167k stars, 47 commits). The minimal definition of a skill is:

skill-name/
├── SKILL.md          # Required: metadata + instructions
├── scripts/          # Optional: executable code
├── references/       # Optional: detailed reference docs
├── assets/           # Optional: templates, images, data files
└── ...               # Any additional files or directories

SKILL.md consists of YAML frontmatter and a Markdown body. The frontmatter field spec is as follows:

Field	Required	Constraints
`name`	✅ Yes	Max 64 chars; lowercase letters, digits, hyphens only; cannot start/end with a hyphen; no consecutive hyphens; must match the parent directory name
`description`	✅ Yes	Max 1024 chars; describes what the skill does and when to use it; should include specific keywords that help the agent recognize relevant tasks
`license`	❌ No	License name or a reference to a bundled license file
`compatibility`	❌ No	Max 500 chars; environment requirements (target product, system dependencies, network access, etc.)
`metadata`	❌ No	Arbitrary string-to-string key-value map for extended properties
`allowed-tools`	❌ No (experimental)	Space-separated tool list, pre-approving the tools the skill may use

A minimal example:

---
name: pdf-processing
description: >-
  Extracts text and tables from PDF files, fills PDF forms, and merges
  multiple PDFs. Use when working with PDF documents or when the user
  mentions PDFs, forms, or document extraction.
---

The Loading Mechanism: Three-Tier Progressive Disclosure

This is the essence of the entire format design. The agent does not load all skills at once; instead it works in three tiers:

Index tier (roughly 100 tokens / skill): at startup, load the name and description fields of all skills—this is the sole basis for the agent's "routing decision";
Body tier (recommended < 5000 tokens): when the agent decides to activate a skill, it loads the full body of SKILL.md;
Reference tier (on demand): the scripts/, references/, and assets/ files referenced in the body are read in only when specifically needed.

Key insight: the description field is the "search engine" of the entire system. Written poorly, the skill will never be activated; written well, the agent can make accurate routing judgments at the cost of 100 tokens. This is why the spec includes a dedicated "Optimizing descriptions" guide.

The official recommendation is to keep SKILL.md under 500 lines, split detailed reference material into separate files, and keep reference depth to no more than one level—preventing the agent from sinking into deep reference chains.

Validation Tools

The official skills-ref reference library validates skill format—checking whether frontmatter is legal and naming follows conventions. This elevates skills from a "documentation convention" to an "engineering spec backed by a toolchain."

II. Where Google's Official Version Fits

Repository Overview

google/skills: 17.2k stars, 1.4k forks, 221 commits, Apache-2.0 license. The description is remarkably direct: "Agent Skills for Google products and technologies".

The repo is labeled "under active development" and has a clear structure:

google/skills/
├── skills/              # Core: 80+ skills
│   ├── ads/             # Ads: Google Ads API, Mobile Ads SDK, IMA SDK
│   ├── analytics/       # Analytics: Google Analytics Admin/Data API
│   └── cloud/           # Cloud: the overwhelming majority, detailed below
├── plugins/             # Plugins (Skills + MCP servers packaged together)
│   └── cloud/data-agent-kit/
├── .agents/plugins/     # Agent framework adapters
├── .claude-plugin/      # Claude Code plugin manifest
└── .gitmodules          # Submodules: Flutter/Dart/Firestore and other standalone repos

Coverage: A Knowledge Graph of Google Products

Google's skills directory is essentially structured teaching documentation for the Google Cloud product matrix. Organized by domain:

Cloud Onboarding & Solution Architecture

Google Cloud certification, Foundation Builder, Onboarding
Multi-product solutions: cross-cloud agentic analytics, open data lakehouse, AI Agent deployment on GKE, RAG enterprise search, Serverless n-tier security architecture…

AI/ML (with Agent Platform at the core)

This is the largest block: Alert configuration, Endpoint management, Eval Flywheel, GenAI inference, Model Garden deployment, Model Registry, Model Tuning, Prompt Management, RAG Engine, Troubleshooting, Tuning Management…
BigQuery AI & ML, Gemini API, Gemini Interactions API, LiveAPI Service, Skill Registry

Infrastructure (GKE alone accounts for 20+ skills)

GKE creation, Autoscaler, ComputeClasses, Golden Path, Multi-Tenancy, Networking, Storage, Reliability, Productionize, TPU dynamic slice monitoring, Workload Scaling/Troubleshooting…
Load balancer configuration, network observability, Cloud Storage fundamentals

Databases & Analytics

AlloyDB, BigFrames, BigQuery (basics + asset impact analysis), Bigtable, Cloud SQL, Data Lineage, Spanner, Airflow migration

Management Tools

Cloud Monitoring chart generation, Cloud Logging configuration (incl. cross-project), log query language generation, GKE cost analysis/optimization/observability, SLO alerts, TPU metrics, Workload Manager

Well-Architected Framework (six pillars)

Cost optimization, operational excellence, performance optimization, reliability, security, sustainability—one skill per pillar

Security & Identity

GKE platform security, GKE workload security, SecOps detection coverage

Web & Application Hosting

Cloud Run fundamentals, Firebase fundamentals

Ads (a surprise inclusion)

Google Ads API (account diagnostics, MCP Server installation, Quickstart), Mobile Ads SDK (Banner/interstitial/rewarded/install), Data Manager API, IMA SDK

Developer Tools

Developer Device Platform, gcloud CLI, Google Agents CLI Onboarding

In addition, independently maintained add-on skills are linked via .gitmodules: Flutter, Dart, Advanced Cloud Storage, Agent Development Kit (ADK), Firestore, Genkit.

What a Real Skill Looks Like

Take skills/cloud/bigquery-basics/SKILL.md as an example:

---
name: bigquery-basics
metadata:
  category: BigDataAndAnalytics
description: >-
  Manages datasets, tables, and jobs in BigQuery. Use when you need to
  interact with BigQuery, run SQL queries, manage BigQuery resources
  (datasets, tables, views), or perform basic data ingestion and analysis.
---

The body contains: BigQuery architecture explanation, specific gcloud/bq CLI commands (enable API, create dataset, create table, run SQL), and a references/ directory with on-demand deep documents like Core Concepts, Change History, and Continuous Queries.

What you can see in Google's approach: strict compliance with the Anthropic format spec, with the addition of metadata.category for internal classification. The instruction body is not abstract methodology but copy-pasteable commands and configuration—a stark contrast to the "engineering methodology" style of community editions.

The Plugin Mechanism: The Skills + MCP Combo

google/skills also packages plugins—combining Skills (knowledge) and MCP servers (tools) together. Three agent frameworks are currently supported:

Agent Framework	Installation
Claude Code	`claude plugin marketplace add google/skills` → `claude plugin install <plugin>@google-plugins`
Codex	`codex plugin marketplace add google/skills` → install from the `/plugins` browser
Antigravity CLI	`agy plugin install https://github.com/google/skills/<plugin-path>`

The universal installation entry point is npx skills add google/skills, which lets you interactively select specific skills.

Google's Version vs. Anthropic's: Similarities and Differences

Dimension	anthropics/skills	google/skills
Positioning	Format definition + example library	Product knowledge base
Skill count	~10+ examples	80+ production-grade skills
Skill type	Creative, technical, enterprise workflows, document processing	Google product operation guides
Knowledge style	Patterns that demonstrate "what's possible"	Executable ops manuals
License	Apache-2.0 (partially source-available)	Apache-2.0
Format innovation	Defines the spec itself	Follows the spec, no extensions
Plugins	Claude Code plugin marketplace	Multi-framework plugins (Claude/Codex/Antigravity)

The key difference: Anthropic is "spec setter + inspiration library," Google is "spec consumer + largest enterprise content contributor." Google didn't invent a new format—it chose to embrace the existing standard. That posture alone is the strongest possible endorsement of format standardization.

III. The Full Ecosystem: A Side-by-Side Comparison of Four Repositories

The Agent Skills ecosystem has now formed clear layers. Below is a comparison of the four most important repositories.

Data at a Glance (as of 2026-08-10)

Repository	Stars	Forks	Commits	Positioning
mattpocock/skills	211k	18.3k	420	Personal engineering methodology
anthropics/skills	167k	19.9k	47	Official spec + examples
addyosmani/agent-skills	85.1k	9.2k	419	Production-grade engineering skill pack
google/skills	17.2k	1.4k	221	Google product knowledge

Note: star counts change continuously; the above is a snapshot from the time of research.

Breaking Down Each One

1. anthropics/skills — The Source of the Spec

Role: The inventor and authoritative definer of the format; the spec has been split out to agentskills.io
Content: A small number of high-quality examples (the docx/pdf/pptx/xlsx document skills are the ones used in Claude's production environment, source-available), plus creative/technical/enterprise workflow demos
Community: 47 commits tells you this isn't a frequently iterated "product"—it's a standard reference implementation
Value: The first stop if you want to understand the format, learn best practices, or see how complex skills are written

2. google/skills — Official Big-Co Content

Role: The official skill library for Google Cloud/Ads/Analytics
Content: 80+ product operation skills, with the deepest GKE coverage (20+), followed by Agent Platform AI/ML
Highlights: Instructions are executable (specific commands rather than abstract methodology); supports multi-framework plugin installation; uses metadata.category for internal classification
Value: Teams using Google Cloud can install directly; everyone else can learn how to write enterprise-grade skills

3. addyosmani/agent-skills — The Engineering Methodology Compendium

A personal project by Addy Osmani (engineering lead on the Google Chrome team), and possibly the most complete general-purpose engineering skill pack available today.

Role: Encoding the workflows of senior engineers into reusable skills
Content: 24 skills, organized around the software lifecycle:
- DEFINE: interview-me (relentless interviewing until 95% confidence), idea-refine, spec-driven-development
- PLAN: planning-and-task-breakdown
- BUILD: incremental-implementation, test-driven-development (red-green-refactor), context-engineering, source-driven-development, doubt-driven-development (CLAIM→EXTRACT→DOUBT→RECONCILE), frontend-ui-engineering, api-and-interface-design
- VERIFY: browser-testing-with-devtools, debugging-and-error-recovery (five-step triage)
- REVIEW: code-review-and-quality (five-axis review), code-simplification, security-and-hardening (OWASP Top 10), performance-optimization
- SHIP: git-workflow-and-versioning, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, observability-and-instrumentation, shipping-and-launch
Highlights:
- 8 slash commands (/spec→/plan→/build→/test→/review→/ship) map to the development lifecycle
- Built-in using-agent-skills meta-skill—helps you decide which skill to use
- 4 expert personas (code-reviewer / test-engineer / security-auditor / web-performance-auditor)
- Framework-neutral: simultaneously adapts to Claude Code, Cursor, Codex, Copilot, Cline, Windsurf, OpenCode, Gemini CLI, Antigravity, and 70+ other agents (via multi-directory adapters like .claude-plugin/.codex-plugin/.gemini/commands/.opencode)
- Has an evals/ directory and CI checks (references link validation)
Value: For teams that want "engineering discipline out of the box," this is the top pick

4. mattpocock/skills — Personal, Battle-Tested Methodology

A personal skill set from Matt Pocock (TypeScript educator, author of Total TypeScript), with the highest star count.

Role: Battle-tested skills distilled from a personal .agents/ directory
Philosophy: Explicitly opposes frameworks like GSD/BMAD/Spec-Kit that "take over the process"—argues that skills should be small, easy to change, composable, and model-agnostic
Content: ~20 skills, in two categories:
- User-invoked: /grill-me (relentless interviewing until every branch of the design tree is resolved), /grill-with-docs (interview + build domain model + ADR), /triage, /to-spec, /to-tickets, /implement, /wayfinder, /improve-codebase-architecture, /setup-matt-pocock-skills
- Model-invoked: prototype, diagnosing-bugs, research, tdd, domain-modeling, codebase-design, code-review, resolving-merge-conflicts, wizard
Highlights:
- The User-invoked vs. Model-invoked dichotomy: user-invoked skills handle orchestration, model-invoked skills hold reusable discipline—the former may call the latter, but not vice versa. This is a clearer architectural principle than addyosmani's.
- Organized around four "common failure modes of AI coding": ① The agent did the wrong thing (→grilling) ② The agent is too verbose (→shared language/domain model) ③ The code doesn't work (→feedback loops/TDD) ④ The code turns into a big ball of mud (→deepening architecture)
- Extensively references classic engineering literature: The Pragmatic Programmer, Domain-Driven Design, Extreme Programming, A Philosophy of Software Design
- Has changeset versioning, a CHANGELOG, and formal releases (v1.2.3)
Value: If you believe "skills should be small, sharp tools rather than bloated frameworks," this is the best reference

How the Four Relate

           Spec Layer               Content Layer
     ┌─────────────────┐    ┌──────────────────────────┐
     │                 │    │ Enterprise product knowledge
     │ anthropics/     │    │  google/skills (80+)
     │ skills (spec)   │    │
     │                 │    │ General engineering methodology
     │ agentskills.io  │    │  addyosmani (24)
     │ (spec site)     │    │  mattpocock (~20)
     └────────┬────────┘    └─────────────┬────────────┘
              │                           │
              └───────────┬───────────────┘
                          ▼
                   Client Support Layer
            (30+ agents, see Section V below)

In summary: these four repositories are not in competition—they form ecosystem layers. Anthropic sets the rules, Google fills in enterprise product knowledge, and two community leaders fill in general engineering methodology. A mature team might install google/skills (cloud ops) + addyosmani (engineering discipline) + mattpocock (requirements clarification) simultaneously. They don't conflict, because they all follow the same format.

IV. A Deep Dive into the Technical Spec

File Structure

The complete structure of a skill:

my-skill/
├── SKILL.md              # Required: the only hard requirement
├── scripts/
│   ├── build.sh          # Executable code (self-contained or documented dependencies)
│   └── analyze.py
├── references/
│   ├── api-details.md    # Detailed technical reference
│   ├── form-templates/   # Form templates, structured data
│   └── domain-glossary.md
└── assets/
    ├── template.docx     # Document templates
    ├── diagram.png       # Diagrams
    └── lookup.json       # Lookup tables, schemas

Conventions (not mandatory):

scripts/ should be self-contained or explicitly document dependencies; include helpful error messages; handle edge cases gracefully. Supported languages depend on the agent implementation (common: Python, Bash, JavaScript)
Individual files in references/ should be focused—the agent loads them on demand, and the smaller the file, the less context it consumes
assets/ holds static resources

The Design Philosophy Behind Frontmatter

Every field in the spec has a clear design intent:

name (required)—identity + filesystem convention:

Must match the parent directory name (bigquery-basics/SKILL.md must have name bigquery-basics)
Naming constraints are strict (lowercase/digits/hyphens, no consecutive hyphens)—ensuring cross-platform path safety

description (required)—the routing engine of the entire system:

The spec explicitly requires "describes what the skill does and when to use it"
Should include "specific keywords that help the agent recognize relevant tasks"
The official docs give a good/bad comparison:
- ✅ Extracts text and tables from PDF files, fills PDF forms, and merges multiple PDFs. Use when working with PDF documents or when the user mentions PDFs, forms, or document extraction.
- ❌ Helps with PDFs.

compatibility (optional)—environment declaration:

Most skills don't need it; only write it when there are specific environment dependencies
Example: Requires git, docker, jq, and access to the internet

metadata (optional)—extension slot:

Google uses it for category; other implementations can extend freely
Recommend making key names distinctive enough to avoid conflicts

allowed-tools (experimental)—pre-approved tools:

Example: Bash(git:*) Bash(jq:*) Read
Experimental; support varies across implementations

The Trigger Mechanism: How the Agent Decides Which Skill to Load

This is the key to understanding the entire format. Triggering is not based on regex matching or explicit invocation, but on semantic routing:

User input + current context
        │
        ▼
┌───────────────────────────┐
│ The agent sees the         │  ← Index tier (~100 tokens per skill)
│ name + description index   │
│ of all skills              │
└─────────────┬─────────────┘
              │ Semantic matching judgment
              ▼
     ┌─────────────────┐
     │ Decides to       │
     │ activate a skill │
     └────────┬────────┘
              │
              ▼
┌───────────────────────────┐
│ Loads the full body of     │  ← Body tier (recommended <5000 tokens)
│ SKILL.md                   │
│ (body may reference files) │
└─────────────┬─────────────┘
              │ Read on demand
              ▼
┌───────────────────────────┐
│ Reads specific files from  │  ← Reference tier (on demand)
│ references/scripts/assets  │
└───────────────────────────┘

Two implications:

Description is life or death—write it vaguely and the skill will never be triggered; write it precisely and the agent can route correctly at minimal cost. This is why "optimizing descriptions" is a craft worth studying in its own right.
File splitting has economic meaning—putting detailed content in references/ instead of cramming it into SKILL.md means that content only consumes tokens when it's genuinely needed.

Implementation Differences in Loading

Although the spec is unified, loading implementations vary across clients:

Claude Code: native support, plugin marketplace mechanism (claude plugin marketplace add)
Claude.ai: paid plans include official example skills; custom skills can be uploaded
Claude API: upload and use via the Skills API
skills.sh CLI (cross-client): npx skills add <repo> installs to 70+ agents, supports --list for browsing and --skill for individual installation
Codex / Cursor / Gemini CLI / GitHub Copilot / Windsurf, etc.: each has its own adaptation path

npx skills add is becoming the de-facto universal installation entry point—no matter which client you use, the install syntax is the same. This further lowers the barrier to format adoption.

V. Why This Format Is Winning the De-Facto Standard War

Breadth of Client Support

The agentskills.io Client Showcase lists 30+ agent products that already support the Agent Skills format, including:

Category	Representative Products
IDE/Editor	VS Code, Cursor, Roo Code, TRAE, Kiro, Junie, VT Code
Terminal agents	Claude Code, Gemini CLI, Codex/ChatGPT, Codex CLI, Amp, Mistral Vibe, OpenCode, Hermes Agent
Platform/Cloud	Snowflake Cortex Code, Databricks Genie Code, Pulumi Neo, Google AI Edge Gallery
Open-source frameworks	OpenHands, Goose, nanobot, Mux, Letta, Spring AI, OpenClaw, ZeroClaw
Enterprise	Factory, Agentman, Superconductor, Ona, Workshop, Piebald, Emdash
Industry-specific	Firebender (Android), Laravel Boost (PHP), Command Code

Notice the composition of this list: it's not just Anthropic's own products. Google, OpenAI (Codex/ChatGPT), Microsoft (GitHub Copilot/VS Code), Snowflake, Databricks, Mistral—coding agents from virtually every major vendor are on it.

Why It Won

Before Agent Skills, there were plenty of similar "knowledge packaging" attempts: various prompt libraries, .cursorrules, AGENTS.md, CLAUDE.md, custom MCP servers… Why did Agent Skills break through?

1. A minimal format definition The smallest skill needs only a folder + one SKILL.md + two frontmatter fields. No schema files, no compilation step, no runtime dependencies. The barrier is so low that anyone can write their first skill in 5 minutes.

2. The context economics of progressive disclosure This is the core competitive advantage. Compared to "cramming all instructions into the system prompt," Skills let you have 100 skills while only paying 100×100=10,000 tokens of index cost—instead of 100×5000=500,000 tokens of full loading. The economics determine how large a knowledge base this format can scale to.

3. Cross-vendor neutrality Anthropic proposed the format but didn't tie it to Claude. agentskills.io is an independent site, the spec is an open document, and anyone can implement a client. Google/OpenAI/Microsoft products support it—not because they were forced to, but because the format is genuinely good.

4. Just the right amount of spec constraint The spec defines "required" and "conventional" but doesn't overreach. name and description are hard constraints; scripts//references//assets/ are soft conventions; body content is completely free. This balance of "strict metadata + free content" lets the format be reliably machine-parsed while accommodating arbitrarily complex human knowledge.

5. The positive feedback loop has already started More client support → more users → more skill creators → more skills → more incentive for clients to support. The combined star count of the four leading repositories (211k + 167k + 85k + 17k = 480k) shows this flywheel is already spinning.

6. skills.sh CLI unified the installation experience No matter what client you use, npx skills add <repo> just works. This eliminates the last bit of friction: "the format is nice, but every tool installs it differently."

Comparison With Other Approaches

Approach	Positioning	Relationship to Skills
`.cursorrules`	Single-file project rules	A functional subset; Skills is a structured superset
`AGENTS.md`/`CLAUDE.md`	Project-level persistent instructions	Complementary—use md files for project-level rules, Skills for reusable workflows
MCP servers	Tool/capability extension	Complementary—MCP gives the agent "hands" (tool calls), Skills give the agent a "brain" (domain knowledge). google/skills plugins package both together
Custom system prompts	One-off instructions	Superseded by the reusability of Skills

Skills isn't trying to replace these approaches—it's filling a niche that was previously empty: "reusable domain knowledge packaging."

VI. Practical Value for Developers: How to Write Skills for Your Own Project

When to Write a Skill

Good candidates for skills:

The team has workflows it runs repeatedly (deployment procedures, code review checklists, incident response)
The project has specific domain knowledge/glossaries/architecture conventions
You use a specific framework/library/cloud service, and the official docs are too long and need condensing
Knowledge needed for new-hire onboarding

Poor candidates:

One-off tasks (just say it in the conversation)
Operations that depend on a lot of dynamic context and can't be documented in advance
Instructions so simple they fit in one sentence (just put them in AGENTS.md/CLAUDE.md)

A Step-by-Step Guide to Writing a Skill

Step 1: Define the trigger condition

First ask yourself: under what circumstances should the agent activate this skill? Write the answer as the description:

---
name: deploy-to-staging
description: >-
  Deploys the current branch to the staging Kubernetes cluster using
  our internal helm charts. Use when the user asks to deploy, push to
  staging, or release a new version for QA testing.
---

Keywords should cover the different ways users might phrase it ("deploy", "push to staging", "release for QA").

Step 2: Write the instruction body

The body is the operations manual for the agent to follow. Recommended structure:

# Deploy to Staging

## Prerequisites
- Ensure you're on the correct branch (git branch --show-current)
- Run `pnpm test` and confirm all tests pass
- Check that .env.staging exists

## Steps
1. Build the Docker image:
   `docker build -t registry.internal/app:$(git rev-parse --short HEAD) .`
2. Push to registry:
   ...
3. Update helm values:
   ...

## Common Issues
- If you see "ImagePullBackOff": check registry credentials
- If migrations fail: ...

## Verification
- After deploy, hit https://staging.example.com/healthz
- Check Grafana dashboard for error spikes

Step 3: Split out reference material

If certain details are long (complete environment variable tables, architecture decision records, API schemas), put them in references/:

deploy-to-staging/
├── SKILL.md
├── references/
│   ├── env-variables.md      # Complete environment variable list
│   ├── rollback-procedure.md # Rollback steps
│   └── helm-values.yaml      # values template
└── scripts/
    └── pre-deploy-check.sh   # Pre-check script

Step 4: Validate

Use the skills-ref library to verify frontmatter legality. Test manually: describe the task in the agent using different phrasings, and see whether the skill is triggered correctly.

Recommendations for Organizing Team-Level Skills

1. Build an internal organizational skills repository

yourorg/skills/
├── skills/
│   ├── deploy-pipeline/
│   ├── code-review-standards/
│   ├── onboarding/
│   └── incident-response/
├── .claude-plugin/
└── README.md

Follow google/skills's directory structure and organize by domain.

2. Manage with git, gate with code review

Skills are knowledge assets and should have a review process just like code. addyosmani/agent-skills even has CI checks that validate references links.

3. Use community skills first, then write your own

Before writing your own, check whether something already exists:

Cloud ops: npx skills add google/skills
Engineering methodology: npx skills add addyosmani/agent-skills
Requirements clarification / TDD: npx skills add mattpocock/skills

Layering your team's customizations on top of community skills is far more efficient than starting from scratch.

4. Consider "negative examples" when writing descriptions

A good description doesn't just say "when to use"—it implicitly says "when not to use." If your skill is easily confused with another, make the distinction in the description.

5. Control the length of SKILL.md

500 lines is the official recommended upper limit. Beyond that, split into references. This isn't fastidiousness—a long body means every activation consumes more context, crowding out reasoning space.

VII. My Position and Predictions

My Judgment

Agent Skills is becoming the first genuinely "cross-vendor" knowledge packaging standard to take hold in the AI coding agent space. The reason is the network effect laid out in Section V: the format is simple enough, the context economics are sound enough, client support is broad enough, and community content is rich enough.

Google's entry is a watershed moment. When a company with a product line as vast as GKE, BigQuery, and Gemini chooses to distribute its product knowledge using a format defined by a competitor (Anthropic), it can only mean one thing: the format war is over. The argument is no longer "should we use Agent Skills," but "whose skills are written better."

Three Predictions

Prediction 1: An "app store" and curation layer for skills will emerge

Today, finding skills means digging through READMEs in various GitHub repos. As the number of skills explodes (Google already has 80+, and the community is still growing), a centralized directory/search/rating platform is inevitable—agentskills.io is already moving in that direction. Curation ("Top 10 Security Skills," "Essential React Development Skill Pack") will become a new content niche.

Prediction 2: The fusion of skills + MCP will deepen

google/skills plugins are already packaging Skills (knowledge) and MCP servers (tools) together. The trend going forward is that a "capability pack" = domain knowledge + callable tools + usage context—all three indispensable. Skills provide "when and how to use"; MCP provides "what you can use." Combined, they form a complete extension of agent capability.

Prediction 3: Enterprise-internal skills management will become a new infrastructure need

When a team accumulates 50+ internal skills, it needs version management, access control, distribution mechanisms, usage analytics, and effectiveness evaluation. This will spawn a new class of internal tools—something like an "enterprise skills registry." google/skills already includes an agent-platform-skill-registry skill, hinting at the direction.

Advice for the Reader

If you're an AI product engineer, my advice is:

Start using it now—install 1-2 community skill packs and experience the effect of progressive disclosure
Write 2-3 skills for your current project—deployment procedures, code review standards, and new-hire onboarding are the best starting points
Track format evolution—the agentskills.io spec and blog are the authoritative sources
Don't over-invest—the format is still evolving (allowed-tools is still experimental); keep your skills small and iterable

This is not another tech trend that will fade away. The standardization of knowledge packaging is a necessary step for AI agents to evolve from "general-purpose chatbots" into "reliable professional tools." Whoever first distills their domain knowledge into high-quality skills will gain a structural efficiency advantage in AI-assisted work.

References

Agent Skills official spec: https://agentskills.io/specification
Client Showcase (30+ supported clients): https://agentskills.io/clients
anthropics/skills (167k stars): https://github.com/anthropics/skills
google/skills (17.2k stars): https://github.com/google/skills
addyosmani/agent-skills (85.1k stars): https://github.com/addyosmani/agent-skills
mattpocock/skills (211k stars): https://github.com/mattpocock/skills
Universal install CLI: https://skills.sh (npx skills add <repo>)

Data in this article is as of August 10, 2026. Star/commit counts are snapshots from the time of research and will continue to change.