Top 10 AI Agent Skills in 2026: The Updated Guide

The honest, fully updated ranking of the agent skills that actually matter in July 2026, with install data, security realities, and what changed since our January list.

The most-installed agent skill in the world now has 2.4 million installs. That skill, find-skills from Vercel Labs, did not even exist when we published the first version of this guide in January 2026. Neither did the leaderboard it sits on. In under six months, the agent skills ecosystem went from a scattered collection of marketplaces counting "accesses" to a single install-tracked registry listing roughly 670,000 skills, an open standard adopted by more than 40 AI clients, a supply chain attack wave that compromised over a thousand packages, and a set of official Anthropic plugins that turned community hacks into supported product features.

This guide is a full refresh of our January 2026 ranking, and we are going to be unusually honest about it: most of our original top 10 is gone. Prompt Lookup, Skill Installer & Lookup, Dify Frontend Tester, and Electron Upgrade Advisor, all of which we ranked in the top 10 in January based on marketplace access counts, do not appear anywhere near the top of the real July 2026 leaderboard. The ecosystem consolidated onto skills.sh, Vercel's install-tracked directory, and the skills that dominate it are a different breed: behavioral skills that change how agents work, official vendor skills from Anthropic, Vercel, and Microsoft, and cross-agent skills that run identically in Claude Code, OpenAI Codex, Gemini CLI, and Cursor.

If you read the January version of this guide, treat this as the corrected record. If you are new: agent skills are the single highest-leverage way to make an AI agent better at a specific job, and this guide covers what they are, the top 10 ranked with real data, the security wave you must not ignore, and how to ship your own. We maintain a much longer companion ranking in our top 100 Claude Code skills guide if you want depth beyond the top 10.

Contents

1. The Top 10 at a Glance: Scores and Methodology
2. What Agent Skills Are in Mid-2026
3. The Leaderboard Flipped: January's Ranking vs July's Reality
4. frontend-design (Anthropic)
5. find-skills (Vercel Labs)
6. vercel-react-best-practices (Vercel)
7. Superpowers (Jesse Vincent / obra)
8. agent-browser (Vercel Labs)
9. grill-me (Matt Pocock)
10. remotion-best-practices (Remotion)
11. web-design-guidelines (Vercel)
12. Ralph Wiggum (Anthropic Official Plugin)
13. microsoft-foundry (Microsoft)
14. The Behavioral-Skills Wave
15. Security: The Malicious-Skill Supply Chain of 2026
16. Skills Beyond Coding: Claude Cowork and Document Work
17. The Enterprise Land-Grab
18. Skills vs MCP vs Plugins vs AGENTS.md
19. How to Ship and Measure Your Own Skill
20. The Models Running Your Skills in July 2026
21. Future Outlook and Decision Framework

1. The Top 10 at a Glance: Scores and Methodology

Ranking skills honestly requires saying what you are optimizing for. Our January list leaned on a single signal, access counts from one marketplace, and that turned out to be a fragile foundation: the marketplace lost relevance within weeks of skills.sh launching, and access counts never distinguished between a skill someone actually installed and one they merely viewed. This time we score each skill on four criteria that map to what a working team actually cares about: adoption momentum (verified installs on skills.sh and GitHub stars as of July 8, 2026), practical impact (how much the skill changes the quality or scope of what the agent produces), portability (whether the skill works across Claude Code, Codex, Gemini CLI, Cursor, and the other clients on the open standard), and trust and maintenance (who publishes it, how actively it is maintained, and how auditable it is, which matters enormously after this year's supply chain attacks).

The weights reflect a deliberate judgment: practical impact carries the most weight at 30% because a skill that transforms output quality beats a popular skill that saves a minute. Adoption and portability each carry 25% because installs are the best available proxy for real-world survival and because single-platform skills are an increasingly bad bet in an open-standard world. Trust carries 20%: lower only because every skill in this top 10 already clears a high trust bar, and the criterion mostly differentiates at the margins. All install figures come from the skills.sh leaderboard and all star counts were verified against the GitHub API on July 8, 2026.

Two things stand out from the scoring. First, official vendor skills dominate: seven of the ten are published by Anthropic, Vercel, Microsoft, or the Remotion team, a complete reversal from January when community marketplaces led. Second, the two community entries that survive, Superpowers and grill-me, are both behavioral skills, which we cover as a category in section 14. Ties are broken alphabetically, which is why grill-me sits above remotion-best-practices at 8.3.

The gap between first and second place is the most important feature of this chart. find-skills has nearly four times the installs of anything else because it is the entry point: most users install it first and then use it to discover everything downstream. Discount that meta-effect and the real race starts at frontend-design.

2. What Agent Skills Are in Mid-2026

An agent skill is a folder. That is still the most useful one-sentence definition: a directory containing a SKILL.md file with YAML frontmatter (a name and a description), a body of instructions, and optionally scripts and reference files the agent can execute or read. When an agent encounters a task that matches the skill's description, it loads the full instructions and follows them. The elegance of the format is progressive disclosure: at rest, the agent only sees each skill's name and one-line description, costing a few dozen tokens per skill; when a skill becomes relevant, the full SKILL.md loads; and bundled scripts or reference documents load only if the workflow actually needs them - Anthropic Engineering. This is why an agent can carry hundreds of skills without drowning its context window, and it is the architectural idea that everything else in this guide builds on.

What changed since January is that this stopped being an Anthropic-only convention. On December 18, 2025, Anthropic published Agent Skills as a formal open standard, with the specification and SDK hosted at agentskills.io - The Decoder. Our January guide hedged that "skills originated with Claude and other platforms are adopting the concept." That hedge is now obsolete. The spec repo has 22,681 GitHub stars, and the adopter list on agentskills.io names more than 40 client integrations: Claude Code and Claude.ai, OpenAI Codex, Gemini CLI, GitHub Copilot, VS Code, Cursor, JetBrains Junie, Amp, OpenCode, OpenHands, Goose, Letta, Factory, Roo Code, Mistral Vibe, TRAE, Kiro, Laravel Boost, Spring AI, Databricks Genie Code, Snowflake Cortex Code, Tabnine, and Qodo among them - agentskills.io.

It helps to see how little machinery this involves. A minimal but complete skill is a folder like this:

my-invoice-triage/
  SKILL.md          # frontmatter: name + description; body: the procedure
  references/
    approval-rules.md   # loaded only if the agent needs the detail
  scripts/
    validate.py         # executed only if the procedure calls for it

The frontmatter description is the skill's entire advertisement to the agent: one or two sentences stating what the skill does and when to use it. Everything else stays on disk until the moment of need. That single design decision explains the format's economics: a 300-skill library costs the agent roughly what a page of prose costs at discovery time, so there is no meaningful penalty for being well-equipped. It also explains why the format spread so easily to other vendors: there is nothing proprietary to implement, just a convention for reading folders, which any agent that can read files can adopt in an afternoon.

The practical consequence of the open standard is write once, run everywhere. A skill you author for Claude Code now runs in OpenAI Codex, where skills are invoked explicitly with a $skill-name mention or selected automatically by the model - OpenAI Codex docs. It runs in Gemini CLI, which documents native skills support - Gemini CLI docs. It runs in GitHub Copilot and VS Code, which document agent skills as a first-class concept - GitHub Docs. At launch, the standard's adopters included Microsoft, OpenAI, Atlassian, Figma, Cursor, and GitHub, with partner-built skills from Canva, Stripe, Notion, and Zapier. For anyone deciding where to invest authoring effort, this settles it: the SKILL.md format is the safest packaging bet in the agent ecosystem, in the same way a Dockerfile became the safest packaging bet for server software.

Distribution consolidated just as fast as the format did. On January 20, 2026, Vercel launched the skills CLI and the skills.sh directory, initially supporting 17 agents and now more than 20 - Vercel changelog. Installing any published skill is now one command:

npx skills add vercel-labs/agent-browser
# or search interactively
npx skills find "video editing"

The scale this unlocked is easy to understate. Our January guide reported "over 31,000 skills in circulation" based on a marketplace counter. By June 2026, skills.sh alone listed approximately 669,670 skills, roughly five months after launch - rywalker.com. That is a twenty-fold difference, and it is not just growth: it is a measurement correction. Install-tracked registries count something real (a CLI action that placed files on a machine), where access counts measured page views. The whole premise of ranking skills changed underneath the old list, which is what section 3 is about.

Claude Code itself also matured as a skills host over the spring. The June 2026 changelog added a disableBundledSkills setting and a /plugin list command on June 4, a --safe-mode flag on June 8 that starts a session with every customization (CLAUDE.md, plugins, skills, hooks, MCP servers) disabled for troubleshooting, nested .claude/skills directory loading with <dir>:<name> clash resolution on June 15, and stacked slash-skill invocation late in the month, letting a single message chain up to five skills - Claude Code changelog. These sound like small platform features, but --safe-mode in particular becomes load-bearing in the security section: it is the fastest way to determine whether a misbehaving agent is being steered by a skill you installed.

3. The Leaderboard Flipped: January's Ranking vs July's Reality

This section exists because we owe readers a correction, and because the correction itself is instructive. In January 2026 we ranked the top 10 skills using access counts from mcpmarket.com, which at the time was the most visible aggregator. Those counts, in the 119,000 to 142,000 range for the leaders, felt authoritative. They were not. They measured marketplace page traffic during a window when the ecosystem had no better signal, and when Vercel shipped an install-tracked registry days before our publication, the ground truth moved. None of our January top 10 except the Vercel and Remotion entries appears anywhere near the top of the July 2026 leaderboard.

Here is the honest before-and-after. Prompt Lookup, our January #1 with roughly 142,000 accesses, is gone from the top ranks entirely: its job (finding good prompts) turned out to be something frontier models do natively, and nothing about it justified an install once agents got better at self-directing. Skill Installer & Lookup (SkillsMP) was superseded wholesale by npx skills add, the find-skills skill at 2.4M installs, and Claude Code's native /plugin marketplace backed by the official plugins directory at 31,793 stars - anthropics/claude-plugins-official. Dify Frontend Tester and Electron Upgrade Advisor were always narrower than their access counts suggested, and neither survived contact with a registry that measures real installs. Next.js Cache Optimizer was absorbed: its useful content lives on inside Vercel's own officially maintained skills, and its framing around older Next.js caching semantics aged out as the ecosystem moved to the Cache Components era.

Because we published the January list, we can offer something no competitor's ranking can: a line-by-line accounting of what happened to every skill we recommended. The table below is that record. It is worth a slow read, because the pattern in the right-hand column (superseded by platform features, absorbed by official vendor skills, or displaced by better-measured competition) is the pattern that will eventually claim entries from the July list too.

Three of ten survived on the merits, one was promoted into the platform itself, and six vanished. The survivors share one property: each encoded a large, maintained body of expert judgment (React performance, accessibility rules, video-as-code patterns) that a base model cannot regenerate reliably on demand. The casualties share the opposite property: each was a thin utility wrapper whose job the platform or the models learned to do natively. That is the selection pressure operating on all 670,000 skills in the registry, and it is worth applying to any skill you are about to depend on: ask whether it would survive its own function being absorbed into the next model generation.

Why did install-tracking win as the source of truth? From first principles: a ranking signal is only as good as the cost of faking or misreading it. A page view costs nothing and conflates curiosity with adoption. An install through a CLI represents a deliberate action that changes the user's machine, gets counted once per real environment, and correlates with continued use because uninstalling is equally deliberate. When Vercel gave the ecosystem a signal with those properties, every serious skill author started publishing there, and the directories that could not verify installs stopped mattering. The same dynamic played out years earlier when npm's download counts displaced awesome-lists as the way JavaScript developers judged libraries. Competing editorial rankings rotated too: Composio's June 15, 2026 top-10 list features frontend-design, Superpowers, agent-browser, the Karpathy behavioral skill, and systematic-debugging, with zero overlap with the January mcpmarket cohort - Composio.

There is a second, subtler reason the list rotated: the category mix changed. January's leaders were utilities (find a prompt, install a skill, test a frontend). July's leaders are dominated by skills that either carry a vendor's authoritative knowledge (frontend-design, react-best-practices, microsoft-foundry) or reshape the agent's working method (Superpowers, grill-me, tdd). Utilities got commoditized by better base models and better platform tooling; encoded expertise and encoded methodology did not. If you want a predictive heuristic for what will still rank in January 2027, that is it: skills survive when they encode something a frontier model cannot regenerate on demand. With that context, here are the ten skills that earn a place today.

4. frontend-design (Anthropic): The Design-Taste Transplant

What it is. frontend-design is Anthropic's official skill for making agent-built interfaces look professionally designed rather than obviously generated. It sits at #2 on the global leaderboard with 638.5K installs - skills.sh. It ships in the official anthropics/skills repository (159,421 stars), alongside Anthropic's document skills, and is available to paid Claude.ai plans as well as every SKILL.md-compatible client. The skill encodes concrete design judgment: typography scale and pairing, spacing systems, color discipline, layout composition, states and affordances, and the dozens of small decisions that separate a credible product UI from bootstrap-flavored output.

Why it ranks #1 here. Impact, portability, and trust all max out or nearly max out. On impact: this is the single most visible before-and-after of any skill in the ecosystem. Ask an agent for a landing page without it and you get competent, generic markup; ask with it and you get deliberate typography, a coherent spacing rhythm, and restrained color. Teams that build user-facing software with agents describe it as non-optional, which the install count corroborates. On portability, it is a pure-knowledge skill (no scripts, no external dependencies), so it runs identically in Claude Code, Codex, Cursor, and any of the 40+ standard clients. On trust, it is maintained inside Anthropic's own repository with the same review bar as their document skills. We covered the broader question of what design capability means for agent platforms in our guide to design capabilities for AI agents, and frontend-design is the reference implementation of the "encode taste as text" approach.

How to use it well. The skill rewards specificity in the surrounding request. It supplies the design system thinking, but you still own the product intent: audience, tone, one or two reference points. The most effective pattern we see is pairing it with an iteration loop: generate, screenshot, critique against the skill's own principles, regenerate. Agent platforms are increasingly wiring this in natively; at O-mega, for example, agents that build web properties apply design-guideline knowledge of this kind as a standing capability rather than a per-session install, which is the direction most managed platforms are heading.

Limitations. It cannot rescue a confused product brief, and it biases toward a recognizable contemporary aesthetic: clean, spacious, type-led. If your brand calls for something deliberately unusual, the skill's defaults become a gravity well you have to actively pull away from. It also concentrates on visual and interaction quality, not information architecture: it will not tell you the page is answering the wrong question. Treat it as a senior designer reviewing your agent's work, not as a product strategist.

5. find-skills (Vercel Labs): The Front Door

What it is. find-skills is the discovery meta-skill: install it once and your agent can search the entire skills.sh registry, evaluate candidates, and install what it needs, from inside the conversation. It is the #1 skill globally at 2.4M installs, nearly four times its closest rival - skills.sh. It is published by Vercel Labs as part of the ecosystem tooling that also includes the skills CLI, whose repo holds 25,490 stars, and the broader vercel-labs/agent-skills collection at 28,820 stars.

Why it matters. In January, discovery was our #2-ranked problem, served by the SkillsMP installer skill. find-skills is the professionalized replacement, and the difference is the backing infrastructure: it searches a registry with real install counts, source links, and publisher identity, which means the agent's recommendation carries signal instead of just availability. The workflow it enables is genuinely new behavior: an agent hits a task it lacks procedure for, searches the registry, reads candidate SKILL.md descriptions, and installs the best match, all inside one session. It converts the 670,000-skill long tail from an overwhelming catalog into an on-demand library. The install count reflects its position as the default first install: Vercel's own onboarding, most tutorials, and most agent-platform setup guides start with it.

How to use it well. Two practices separate power users from defaults. First, constrain the source: ask the agent to prefer skills from publishers you already trust (anthropics, vercel-labs, microsoft, remotion-dev, or your own org) rather than raw popularity. Second, review before activation: have the agent print the SKILL.md of anything it proposes to install and read it yourself. That habit costs thirty seconds and is your primary defense against the supply chain problem covered in section 15, because discovery skills are precisely the mechanism that turns one careless session into an installed backdoor.

Limitations. Its impact score is the lowest of the top 10 (7) because it does not improve any output directly: it is plumbing, indispensable plumbing, but plumbing. It is also only as good as the registry's hygiene. skills.sh verifies installs, not safety, and find-skills will happily surface a well-described malicious skill if one slips through. The 2.4M installs make it the single most attractive target in the ecosystem for typosquatting and dependency-confusion attacks, which is exactly why the vetting habit above matters.

6. vercel-react-best-practices (Vercel): A Decade of Performance Review, Inlined

What it is. vercel-react-best-practices is the direct descendant of the "React Best Practices" skill we ranked #3 in January, now officially maintained, substantially expanded, and sitting at #3 globally with 534.2K installs - skills.sh. It packages Vercel's accumulated React and Next.js performance judgment into rules the agent applies while writing or reviewing code: parallelizing data fetches instead of waterfalling them, keeping client bundles lean, respecting server/client component boundaries, avoiding render cascades, and dozens of similar patterns with concrete bad-versus-good examples.

What changed since January. Our original entry described this skill in its launch week. Six months on, two things are different. First, the ecosystem context: our January list also included a separate community "Next.js Cache Optimizer" skill built around older Next.js caching semantics. That skill is no longer a leaderboard item, and its territory now belongs to Vercel's official skills, which track the framework's current Cache Components era rather than speculating about it. When the vendor whose framework you are optimizing publishes and maintains the optimization skill, the community mirror loses its reason to exist. Second, maturity: the rule set has been through six months of issue reports and framework releases, which is exactly the maintenance property you want in a skill you let loose on production code.

Why it earns 8.8. Its impact is concrete and measurable: the failure modes it catches (waterfalls, oversized client bundles, unnecessary client components) are the dominant real-world causes of slow React apps, and agents without this knowledge reproduce those failure modes constantly because so much of their training data does. Portability is near-perfect since it is knowledge-only. The reason it does not rank higher is scope: it is worth 9-10 to a React/Next.js team and roughly zero to everyone else. If you build with agents on other stacks, the transferable lesson is the pattern: find the skill in which your framework's vendor encoded their performance review culture, and if it does not exist, that is your cue to write it. Our guide to building live apps with Claude Code shows this skill in a full working pipeline.

Limitations. The skill enforces Vercel's opinions, which are well-earned but not neutral: it will steer architectures toward patterns that shine on Vercel's platform. Most of its advice is platform-agnostic, but keep that provenance in mind when it makes deployment-adjacent suggestions. And like every review skill, it identifies problems more reliably than it sizes them: it can flag twelve issues in a file where only two matter for your traffic profile, so you still decide what is worth fixing.

7. Superpowers (Jesse Vincent / obra): The Methodology, Not the Trick

What it is. Superpowers is the most-starred skills repository on GitHub at 249,557 stars and 22,145 forks, created by Jesse Vincent in October 2025 - obra/superpowers. It is not one skill but an integrated software development methodology delivered as a skill framework: test-driven development discipline, systematic debugging procedures, subagent orchestration patterns, planning and brainstorming protocols, and meta-skills that teach the agent how to acquire further skills. Installing it changes the agent's entire working posture, from "generate code when asked" to "operate a development process."

Why it is the top community entry. Superpowers gets the only perfect impact score (10) in our table because it addresses the layer above every other skill on this list: not what the agent knows, but how it works. The TDD component forces the agent to write a failing test before implementation, which converts the model's confident-but-wrong tendencies into fast, visible feedback. The systematic debugging component replaces the common agent failure spiral (guess, patch, guess again) with hypothesis-driven diagnosis. The subagent patterns let a long task fan out to fresh-context workers instead of degrading inside one bloated session. Each of these is the encoded version of something senior engineers spend years internalizing, and the star count, unprecedented for a skills repo, reflects how strongly that resonated. It did not exist when our January guide was published, which makes it the biggest single omission we are correcting.

How to use it well. Superpowers rewards commitment and punishes cherry-picking. Teams that adopt the full loop (brainstorm, plan, TDD implementation, systematic verification) report the compounding benefit: each phase's output disciplines the next. Teams that install it but override its process in every session get little beyond extra context load. Start with one real feature built end-to-end under the methodology before judging it. It pairs naturally with loop-style execution, which we cover in depth in our guide to writing loops for AI coding agents, because a methodology plus an autonomous loop is precisely what makes overnight unattended work trustworthy.

A concrete session shape makes the difference tangible. Without Superpowers, "add rate limiting to the API" typically produces an immediate implementation: plausible middleware, no tests, no investigation of the existing auth flow it might break. Under the methodology, the same request first produces a short brainstorm of approaches with trade-offs, then a plan with explicit verification steps, then a failing test that defines correct behavior, then the implementation, then a debugging protocol if anything fails, with subagents handling research tangents so the main context stays clean. The elapsed time roughly doubles; the probability the change survives code review without rework goes up far more than that. That trade is the whole proposition, and it is why the repo's fork count (22,145) is as telling as its stars: teams are not just endorsing it, they are adapting the methodology to their own conventions.

Limitations. Its trust score (7) is the lowest in the top 10, not because of any incident but because of structure: it is a fast-moving, opinionated, solo-led project, and its updates change agent behavior more deeply than a rules-list skill ever could. Pin a version for team use and review changes before upgrading. It is also heavyweight: for quick one-file edits, the full process is overhead, and experienced users learn to scope when the methodology engages. Ports beyond Claude Code exist but the deepest integration remains Claude-first, which costs it portability points.

8. agent-browser (Vercel Labs): Hands for the Web

What it is. agent-browser gives coding agents a controllable browser through a ref-based command interface: the agent snapshots a page, gets stable element references, and issues click, type, and navigation commands against them. Launched January 11, 2026, it reached 523.1K installs (#4 globally) and 38,078 GitHub stars by July 8 - skills.sh. The design insight is economy: rather than screenshot-driven vision loops, the agent works from a structured accessibility-tree snapshot, which is faster, cheaper, and far less flaky than pixel-based automation.

Why it matters. A coding agent without a browser cannot verify its own work: it can write a UI but not see it render, produce a checkout flow but not walk through it. agent-browser closes that loop, and closing the verification loop is the single biggest reliability upgrade available to agent-built software. The skill also unlocks the broader category of web work: form automation, scraping, end-to-end testing, competitive research. It is the piece that turns "code generator" into "software builder who checks their work." For the mechanics of how ref-based automation compares to vision-based and CDP-based approaches, our browser automation insider guide goes deep on the trade-offs, and our guide to adding browser automation to your AI agent covers implementation. Full agent platforms bundle this capability natively: O-mega agents, for instance, run managed browser sessions as a built-in session type rather than a skill install, which trades flexibility for zero setup.

How to use it well. The highest-value pattern is self-verification: after the agent builds or changes a flow, require it to drive that flow in the browser and report what it observed before declaring success. Second-highest is scheduled checks: agents that periodically walk your critical user journeys and file issues when something breaks. Both patterns work because the skill returns structured observations the agent can reason about, not just screenshots a human must inspect.

Limitations. It operates a real browser, so it inherits the web's hostility: login walls, CAPTCHAs, bot detection, and rate limits are its weather. It is scoped to what a browser can reach and deliberately does not solve authentication vaulting or IP rotation, which production scraping needs and which stealth-browser infrastructure addresses separately. And handing an agent a browser widens the security surface: a malicious page's content becomes agent input, which is a prompt-injection vector you should assume is being actively exploited this year.

9. grill-me (Matt Pocock): The Interrogation Before the Build

What it is. grill-me inverts the usual agent interaction. Instead of taking your request and building immediately, the agent interrogates you first: what is this for, who uses it, what are the constraints, what does done mean, what should explicitly not happen. Only when the requirements survive the grilling does implementation start. It is the #5 skill globally at 479.9K installs - skills.sh, and the flagship of Matt Pocock's "Skills for Real Engineers" repository at 160,814 stars - mattpocock/skills.

Why a questioning skill outranks most capability skills. Because the most expensive failure mode in agent-assisted work is not bad code, it is a confident build in the wrong direction. Frontier models are strong enough that they will competently construct whatever you underspecified, and you discover the misunderstanding only after reviewing a finished, wrong artifact. grill-me moves that discovery to minute one, where it costs a conversation instead of a rebuild. The economics are stark: thirty seconds of annoying questions versus thirty minutes of regenerated work, multiplied across every ambiguous request you make. Its siblings reinforce the same philosophy and also chart: grill-with-docs (#10, 398.1K installs) grills you against your own documentation, improve-codebase-architecture (#11, 393.5K) and tdd (#13, 375.5K) round out Pocock's four entries in the global top 15.

How to use it well. Use it selectively and honestly. Selectively: prefix it to anything ambiguous, novel, or expensive to redo, and skip it for mechanical tasks where the spec is genuinely complete. Honestly: the skill only works if you answer the questions rather than brushing them off, because your answers become the working spec for the build. Teams get a second-order benefit they rarely anticipate: the grilling transcript is documentation, capturing the requirements conversation that normally evaporates.

Limitations. It adds latency and friction by design, and on tasks that did not need it the friction is pure cost. It also cannot ask questions about unknowns outside your head: if neither you nor the agent knows a constraint exists, no interrogation surfaces it. And its value depends on the model's questioning quality, which is high with current frontier models but degrades on smaller ones that ask generic checklist questions instead of load-bearing ones.

10. remotion-best-practices (Remotion): Video as Code, Grown Up

What it is. remotion-best-practices teaches agents to build videos programmatically with Remotion, the React-based video framework. In January we covered it days after launch and warned it "may be buggy." That framing is now obsolete: it is the #8 most-installed skill globally at 414.5K installs - skills.sh, and a mature, officially documented set of 28 modular rule files covering 9 component patterns, 7 transition types, animation primitives, and audio handling - Remotion docs. It works across Claude Code, Codex CLI, and Cursor, and remains the only serious entry in its category.

Why it holds a top-10 slot. It is the clearest example of a skill unlocking a genuinely new output type rather than improving an existing one. Text-to-video diffusion models generate footage you cannot precisely control; Remotion-driven agents generate videos that are deterministic, editable code: exact brand colors, data-driven charts animated from real numbers, per-frame control, re-renderable when the data changes. That makes it the production tool for the video categories businesses actually ship repeatedly: product demos, data explainers, social clips, personalized onboarding videos. The 28-rule structure is also quietly a masterclass in skill authoring: small composable rules the agent loads per need, rather than one monolithic instruction file, which is progressive disclosure applied inside a single skill.

How to use it well. Treat video generation as a code project, because it is one: the agent scaffolds a Remotion composition, you preview, you give notes, it revises. The teams getting the most from it maintain a small library of their own brand components (lower thirds, intro cards, chart themes) that the agent composes per video, which turns each new video from a from-scratch build into an assembly job. Rendering is compute-heavy, so budget for local render time or a cloud rendering pipeline once volume grows.

Limitations. The ceiling is Remotion's expressiveness: motion-graphics and composition work, not cinematic footage, and anything requiring generated live-action still means pairing with a video model and using Remotion for assembly. Iteration speed is bounded by render previews. And while the skill dramatically raises the floor, taste still matters: agents produce technically correct animations whose pacing feels mechanical until you give explicit direction about rhythm and restraint.

11. web-design-guidelines (Vercel): The Hundred-Point Audit

What it is. web-design-guidelines is Vercel's audit skill: over 100 concrete rules covering accessibility (ARIA usage, alt text, focus order, contrast), form behavior, keyboard navigation, responsive layout, typography, dark mode, touch targets, and internationalization. It sits at #6 globally with 446.8K installs - skills.sh. Where frontend-design shapes what the agent creates, this skill inspects what already exists: point it at a page or a component tree and it produces a findings list with the violated rule and the fix.

Why it persists from the January list. It is one of only three January entries to survive, and the reason is that audit checklists are the perfect content type for the skill format. Accessibility knowledge is voluminous, precise, and dull, exactly the profile of expertise that humans skip under deadline and agents execute perfectly every time. The rules are also objective enough that the agent's findings are mostly verifiable on inspection, which keeps trust high. With accessibility enforcement tightening (the European Accessibility Act's obligations now apply to most consumer-facing digital services), a systematic a11y pass moved from virtue to compliance requirement for many teams, and this skill is the cheapest systematic pass available.

How to use it well. Wire it into the definition of done rather than running it as an occasional cleanup: an agent that audits every new page or component before marking work complete catches issues when they are one-line fixes. Pair it with agent-browser so findings come from the rendered DOM rather than static code reading, which catches the runtime issues (focus traps, contrast in actual computed colors) that code review misses.

Limitations. It measures conformance, not experience: a page can pass all hundred rules and still confuse users, because task-flow quality is not rule-checkable. It can also produce false positives on intentional patterns (decorative images, deliberate focus handling), so findings need a human accept/reject pass rather than blind auto-fixing. Scope is web only; native mobile accessibility needs different tooling.

12. Ralph Wiggum (Anthropic Official Plugin): The Loop That Got Adopted

What it is. Ralph is the technique of running an agent in a persistent loop against a goal until the work is verifiably done, named after the Simpsons character and pioneered by Geoffrey Huntley as a bash while-loop. In January we described it as "an unofficial skill, more like a technique packaged as a skill." That description is now two generations stale: Anthropic ships an official ralph-wiggum plugin inside the Claude Code repository, implemented with a Stop Hook that intercepts the agent's attempts to finish and re-feeds the goal until completion criteria are met - anthropics/claude-code, and Claude Code gained built-in /loop, /goal, and /batch commands that make looping a native platform primitive. HumanLayer's "A Brief History of Ralph" documents the full arc from bash hack to official adoption - HumanLayer.

Why it ranks despite living off-registry. Ralph's adoption score suffers from distribution (it ships through Claude Code's plugin channel, not skills.sh, so it has no comparable install count), but its impact score is a 9 because the documented outcomes are unlike anything else on this list. The Register's January 27, 2026 coverage describes Y Combinator teams shipping six repositories overnight for $297 in API costs using Ralph loops, and Huntley himself ran a three-month continuous loop that built an entire programming language, compiler included - The Register. The pattern works because of a structural insight: agents fail long tasks mainly through context degradation, and a loop that restarts with fresh context, durable external memory, and a completion sentinel converts one failing marathon into many reliable sprints. We dissected these mechanics, including stuck detection and memory-file design, in our guide to long-running coding agents.

How to use it well. Three preconditions separate productive loops from expensive noise. First, a machine-checkable goal: a test suite, a build target, a measurable metric, because "make it better" loops forever. Second, external memory: a progress file the loop reads and updates each pass, so iterations compound instead of repeating. Third, spend and iteration caps: the $297 overnight number is the success story, and the cautionary stories are the unbounded loops that burned multiples of that while stuck. When those preconditions hold, loops beat single-shot prompting on any task too large for one context window; when they do not, loops are strictly worse.

Limitations. Cost variance is the big one: loops convert task ambiguity directly into API spend. Quality is convergent but not elegant; looped code reaches "passes all checks" before it reaches "well-designed," so budget a refactor pass. And loops amplify whatever is in the environment, including any malicious skill instructions, which makes the security hygiene in section 15 a precondition rather than a nicety. Portability is Claude Code-centric today, though the loop pattern itself is replicable on any agent with hooks.

13. microsoft-foundry (Microsoft): The Enterprise Beachhead

What it is. microsoft-foundry is the flagship of Microsoft's azure-skills repository, teaching agents to work with Azure AI Foundry: provisioning model deployments, wiring evaluations, configuring agents and serving infrastructure, and following Azure's reference patterns. It holds 438.5K installs (#7 globally), and the repository, created only on February 26, 2026, holds four of the top-15 global slots: microsoft-foundry, azure-hosted-copilot-sdk at 406.9K, azure-compute at 377.6K, and azure-cloud-migrate at 367.5K - skills.sh.

Why it makes the cut. Individually it is the narrowest skill in the top 10, and its scores show that. Collectively, what it represents is one of the most important facts about 2026: Microsoft validated the format. Four months from repo creation to four top-15 slots means enterprise developers are installing vendor cloud skills at consumer-app rates, and it means the largest enterprise software company on earth decided the SKILL.md format, an Anthropic-originated standard, was where its cloud documentation should live in agent-readable form. For anyone betting on which packaging format survives, that endorsement matters more than any single skill's content. The practical value is real too: Azure's surface area is enormous and fast-moving, and an agent with current, vendor-maintained Azure procedure outperforms one reasoning from stale training data on every provisioning and migration task.

How to use it well. If your infrastructure is on Azure, install the specific azure-skills relevant to your services and treat them as the agent-facing mirror of your platform documentation. The highest-value use case we see is migrations and audits: azure-cloud-migrate encodes assessment procedure that would otherwise require a solutions architect's checklist, and agents execute it consistently across dozens of workloads.

Limitations. Value is gated entirely on Azure adoption; for non-Azure teams it is a zero. Vendor skills also carry a mild steering bias, in the same way react-best-practices carries Vercel's opinions: the encoded procedures favor the vendor's preferred architectures and services. That is usually fine (the vendor's preferred path is usually the well-supported path) but worth naming, and section 17 takes up the platform-lock-in question this trend raises.

14. The Behavioral-Skills Wave

The most important category shift between January and July is one our original taxonomy could not even express. The January list sorted skills by what domain knowledge they added: prompts, React, video, Electron. The July leaderboard is dominated by a category that adds no domain knowledge at all: behavioral skills, which change how the agent works rather than what it knows. Superpowers imposes a development methodology. grill-me imposes requirements discipline. tdd imposes test-first sequencing. The Karpathy behavioral skill imposes restraint. These are procedural interventions in the agent's default behavior, and they now hold the top community slots by both stars and installs.

The Karpathy skill deserves its own paragraph because its trajectory says so much about what the market wants. multica-ai/andrej-karpathy-skills, created January 27, 2026, packages just 4 rules distilled from Andrej Karpathy's public observations about LLM coding pitfalls: the tendencies toward overcomplication, unnecessary defensive code, bloated implementations, and ignoring existing codebase conventions. Four rules. It hit 189,397 GitHub stars by July, one of the fastest-growing repositories of the year. There is no capability in it whatsoever; it is a leash, and it became one of the most-adopted artifacts in the ecosystem because everyone who works seriously with coding agents recognized the failure modes it names.

Why did this wave happen now? From first principles: as base models got stronger through 2026, the binding constraint on agent output quality moved. In 2025, agents failed because they could not do things, so the market wanted capability skills. By mid-2026, frontier models fail far less on capability and far more on judgment defaults: they overbuild, they under-ask, they skip verification, they plow past ambiguity. Knowledge skills cannot fix judgment defaults; procedural constraints can. The behavioral wave is the ecosystem discovering that the highest-leverage text you can put in front of a strong model is not information, it is discipline. This maps directly to what we found when analyzing Claude Code's own internals in our leaked source analysis: the system prompt itself is mostly behavioral constraint, and behavioral skills are users extending that layer.

The practical takeaway for a team assembling a skill stack: install behavioral skills before capability skills. A disciplined agent with two knowledge skills outperforms an undisciplined agent with twenty, because the behavioral layer determines whether any knowledge gets applied at the right moment. The stack that keeps recurring among heavy users is one methodology skill (Superpowers or a lighter tdd), one requirements skill (grill-me), one restraint skill (Karpathy rules), and then domain knowledge as the work demands.

15. Security: The Malicious-Skill Supply Chain of 2026

The defining skills story of 2026 is not on any leaderboard. In early February, Palo Alto Networks' Unit 42 analyzed skills on the OpenClaw marketplace and found that roughly 17% carried malicious payloads, and the associated ClawHavoc campaign compromised more than 1,184 skills, about one in five packages at the time of discovery - Unit 42. Our January guide devoted zero words to security. That omission looks negligent in hindsight, and this section is the correction: if you install skills, you are running a package manager for your AI's brain, and 2026 proved the packages get poisoned.

The attack anatomy matters because it is genuinely novel. A large-scale 2026 empirical study of malicious skills in the wild documents two distinct classes - arXiv. Code-level attacks are the familiar kind: a skill bundles scripts, the agent executes them, the script exfiltrates credentials or establishes persistence. Your existing security intuitions roughly apply. Instruction-level attacks are the new kind: the SKILL.md itself contains directives that steer the agent, telling it to quietly include data in outbound requests, weaken code it writes, or persist instructions into other files. No executable payload exists to scan; the weapon is prose, the execution engine is the model's own instruction-following, and the attack activates only in the semantic context the attacker chose. Traditional supply chain tooling is blind to this class, which is why an academic cottage industry (MalSkillBench, PhantomSkill, SkillSieve, and at least five more arXiv papers this year) formed around detecting it.

The research wave that followed is worth knowing by name, because it maps the threat surface more precisely than any vendor advisory. MalSkillBench built the first large benchmark of malicious skill samples so detection tools can be evaluated against a common corpus rather than anecdotes. PhantomSkill demonstrated attacks that stay dormant through review and activate only under specific runtime conditions, which is the property that makes read-before-install necessary but not sufficient. SkillSieve and its successors work the defense side, classifying skills by comparing declared purpose against the actual behavioral footprint of their instructions. At least eight arXiv papers on SKILL.md attacks appeared in the first half of 2026 alone, a research velocity that tells you the academic community rates this as a durable problem class, not a passing incident. The honest summary of the state of the art: code-level payloads are increasingly catchable, instruction-level attacks are detectable in bulk but not reliably in any single case, and the gap between those two sentences is where your vetting habits live.

Structurally, the ecosystem recreated the npm supply chain problem with a worse detection story and a more powerful execution context: agents run with broad filesystem, shell, and network access, and skills are marketed, by design, as things you install casually mid-conversation. The defense posture that follows is not optional hygiene, it is the cost of participation. Concretely:

• Read before you run: open the SKILL.md and every bundled script of anything you install; if you cannot explain what an instruction is for, do not install it
• Pin trusted publishers: prefer anthropics, vercel-labs, microsoft, remotion-dev, and your own org; treat unknown publishers as untrusted code review subjects
• Use the platform kill switches: Claude Code's --safe-mode (all skills, hooks, plugins, and MCP servers off) and disableBundledSkills exist precisely for triage when behavior turns weird - Claude Code changelog
• Scope credentials: agents with skills installed should hold least-privilege tokens, so a compromised session has a bounded blast radius
• Audit periodically: skills update; a publisher compromise can turn yesterday's safe install into today's payload, exactly like npm

The checklist is deliberately short because the habit matters more than the length. The one-sentence version: treat every skill as code you are deploying to your most privileged machine, because that is literally what it is. Managed platforms carry this burden for their users, which is a real part of their value: on O-mega, for instance, the skill library agents draw from is curated and executed inside controlled sessions rather than on the user's own machine, trading some flexibility for a much smaller attack surface. If you self-host your agent stack, you are your own security team, and this year supplied 1,184 reasons to act like it.

16. Skills Beyond Coding: Claude Cowork and Document Work

Every skill profiled so far touches software, and in January that scoping was defensible: skills lived in developer tools, so skills were a developer topic. That framing broke on January's other launch. Claude Cowork, Anthropic's agent for non-coders, shipped as a desktop app in January 2026 and expanded to web and mobile with cloud execution on July 7, 2026 for Max subscribers - TechCrunch. The number that reframes this entire guide: more than 90% of Cowork usage is non-software work, roughly half of it business operations or content creation. The same SKILL.md format that teaches a coding agent React performance now teaches an office agent how to process invoices, and the office is the larger market.

The bridge is Anthropic's own document skills. The official anthropics/skills repository bundles skills for docx, pdf, pptx, and xlsx creation and manipulation, available to paid Claude.ai plans, and frontend-design from the same repo carries 638.5K installs. Add the partner skills announced with the open standard (Canva, Stripe, Notion, Zapier, plus Figma and Atlassian among the launch adopters) and the shape of the non-developer skills economy is visible: vendors publish skills that make their products operable by agents, and knowledge workers install procedures the way they once installed apps - The Decoder. A marketing manager's Cowork session with a brand-guidelines skill, a pptx skill, and a Canva skill is doing exactly what a developer's Claude Code session does with react-best-practices, just aimed at a deck instead of a codebase.

A worked example shows what non-developer skill adoption actually looks like, because it is less exotic than the developer version. Consider a finance operator who processes vendor invoices weekly: the recurring procedure is extract fields from PDFs, check amounts against purchase orders, flag mismatches over a threshold, and produce a summary spreadsheet. Encoded as a private skill, that becomes a SKILL.md describing the extraction fields and tolerance rules, referencing the pdf and xlsx document skills for the mechanical work, with the company's own escalation thresholds in a reference file. The first week, writing it costs an hour. Every subsequent week, the procedure runs in Cowork in minutes, identically, including the edge-case handling that previously lived in one employee's head. Multiply that shape across the recurring workflows of any operations, marketing, or HR function and you have the actual mechanism by which the 90% non-software figure came to be: not exotic new capabilities, but ordinary procedures finally having a durable, executable home.

Why this matters for how you should think about skills: the taxonomy of this guide's January edition assumed skills answer "what can my coding agent do." The mid-2026 question is "what procedures does my organization run, and which are encoded yet." Every recurring workflow (weekly reporting, invoice triage, content repurposing, applicant screening) is a candidate SKILL.md, and the companies systematically encoding their procedures are compounding an asset competitors cannot download. We cover Cowork's pricing, platform mechanics, and rollout in detail in our Claude Cowork guide, and the agent-ecosystem view in our Cowork pricing and ecosystem analysis. Consumer pricing context for all of this: Claude Pro is $17/month annual ($20 monthly), Max starts at $100/month, and both now bundle Claude Code and Cowork, with Team at $20 per seat annual - claude.com/pricing.

The same logic extends to autonomous agent platforms, where skills become workforce training rather than tool configuration. Platforms like O-mega operate on exactly this premise: agents in a company workspace accumulate private skills (the organization's own procedures) alongside public ones, so the workforce gets better at your business specifically, not just at software in general. That private-skill layer, organizational procedure encoded once and executed by every agent thereafter, is where most of the durable value in this ecosystem will end up, because it is the only part competitors cannot install.

17. The Enterprise Land-Grab

Microsoft's azure-skills sprint (repo created February 26, four of the global top 15 by July) is the loudest data point in a broader pattern: enterprise vendors are racing to own the agent-readable version of their platforms. Databricks Genie Code and Snowflake Cortex Code both ship skills support and appear on the agentskills.io adopter list, meaning the two dominant data platforms decided their query and pipeline procedures should be installable into any compliant agent - agentskills.io. Agent Skills also shipped for Claude enterprise plans, giving IT departments centralized distribution of approved skills across an organization.

The strategic logic is worth spelling out because it predicts what happens next. For a platform vendor, an official skill is simultaneously documentation, onboarding, and moat. Documentation, because it is the platform's procedures in executable form, always fresher than training data. Onboarding, because an agent with the vendor's skill makes a developer productive on the platform in minutes. Moat, because once an organization's agents fluently operate Azure (or Databricks, or Stripe), the switching cost of retraining workflows onto a competitor grows quietly with every automated procedure. This is the classic developer-relations playbook compressed into a folder of markdown, and it explains why the quality bar on official vendor skills is so high: they are competing artifacts, not community contributions.

There is a tension here the open standard only partially resolves. The format is portable: microsoft-foundry runs in Claude Code, Codex, or Gemini CLI alike, so no agent vendor locks you in. But the content steers: each vendor skill encodes its publisher's preferred architecture, and an agent stack assembled entirely from vendor skills will build you a system shaped by those vendors' interests. The counterweight is deliberate: pair vendor skills with behavioral skills that enforce your own review discipline, and maintain private skills that encode your architecture decisions so the agent weighs your constraints against the vendor's defaults. The enterprise pattern that seems to be stabilizing is a three-layer stack: open-standard behavioral skills at the base, vendor skills for platform procedure, private organizational skills on top, with the org layer having the final word.

Read this chart against the install chart from section 1 and a split emerges that is easy to miss: stars and installs measure different communities. The star leaders (Superpowers, Karpathy, Pocock) are community methodology repos developers evaluate and endorse; the install leaders skew toward official utility and knowledge skills that get pulled automatically during setup. A skill stack built only from one chart misses half the ecosystem.

18. Skills vs MCP vs Plugins vs AGENTS.md

Mid-2026's agent stack has four extension mechanisms that get conflated constantly, and choosing wrong wastes context, money, or both. The clean disambiguation: skills are procedures, knowledge loaded on demand that changes how the agent performs a task. MCP is connectivity, live tool connections through the Model Context Protocol that let the agent call external systems (databases, APIs, SaaS products) at runtime. Plugins are packaging, Claude Code's bundle format that ships skills, hooks, slash commands, and MCP configuration as one installable unit, which is how Ralph Wiggum ships. AGENTS.md is standing context, a per-repository instruction file read automatically by Codex and a growing list of agents, holding the always-relevant conventions of one codebase.

The composition rules follow from what each layer is. A skill can instruct the agent to use an MCP tool (the procedure says "query the warehouse via the MCP connection"), which is the correct division of labor: MCP provides the verb, the skill provides the judgment about when and how. AGENTS.md holds only what applies to every task in the repo (build commands, conventions, forbidden directories) because it is loaded unconditionally and every token in it taxes every session, where a skill's tokens are spent only when triggered. Plugins wrap any of the above for distribution. If a piece of guidance is conditional, it belongs in a skill; if it is universal to a repo, AGENTS.md; if it requires a live external system, MCP; if it needs to ship as a unit with hooks or commands, a plugin.

The frequent practical mistake runs in both directions. Teams reimplement API documentation as MCP servers when a skill plus a plain HTTP call would do, paying server maintenance for what is really just procedure. And teams stuff giant procedure documents into AGENTS.md or MCP tool descriptions, paying unconditional context tax for conditional knowledge. The test that resolves most cases: ask whether the thing you are adding is knowledge (skill), access (MCP), repo law (AGENTS.md), or a shippable combination (plugin). For readers building the connectivity side, our MCP server building guide covers the tool layer, and our ranking of the 50 best MCP servers maps the ecosystem skills increasingly orchestrate.

19. How to Ship and Measure Your Own Skill

The 670,000-skill registry can read as "everything is taken," but the install distribution says the opposite: a tiny head of general-purpose skills, then an enormous tail of thin coverage, and the head itself keeps getting displaced (three survivors from January's ten). The opportunity in mid-2026 is specificity. The generic categories are locked up by vendors and famous names; the skills that break out now encode expertise that is scarce: your framework's migration path, your industry's compliance procedure, your niche tool's best practices. grill-me is the proof that a well-shaped idea, four files of it, can reach the global top five from a solo author.

Authoring got dramatically easier since January, when our #10 slot went to a "Skill Writer" assistant. That job is now built into the ecosystem's own tooling: Anthropic's skill-creator skill scaffolds structure interactively, and the format itself is documented at agentskills.io/specification. The craft that remains is editorial, and three principles carry most of it. Write the description line for retrieval: it is the only text the agent sees at discovery time, so it must state precisely when the skill applies, in the vocabulary a user's request would contain. Structure for progressive disclosure: a lean SKILL.md holding the core procedure, with depth pushed into reference files loaded on demand, the pattern Remotion's 28-file structure demonstrates at production scale. And test against the failure you are fixing: run the same tasks with and without the skill installed, and keep only instructions that change behavior, because every sentence that does not is context tax on every future activation.

The description line deserves one concrete illustration because it is where most first-time authors fail. Compare these two frontmatter blocks for the same hypothetical skill:

# Weak: vague, matches everything and nothing
name: database-helper
description: Helps with database tasks.

# Strong: states the trigger conditions in the user's vocabulary
name: postgres-migration-review
description: Reviews PostgreSQL schema migrations for locking hazards,
  irreversible operations, and missing indexes before they run against
  production. Use when writing, reviewing, or debugging a migration file.

The weak version either never activates or activates constantly; the strong version activates exactly when a migration is in play, because its description contains the words a real request would contain. Since discovery-time matching is the only mechanism deciding whether your carefully written procedure ever loads, the description line is not metadata, it is the skill's API. Skill authors who test nothing else should at least test activation: issue five requests that should trigger the skill and five that should not, and check the hit rate in both directions.

Publishing and measurement run through the same pipe as consumption. Push the skill to a public GitHub repository and it is installable immediately via npx skills add your-org/your-skill, with skills.sh tracking installs from that moment - Vercel changelog. Install counts are the scoreboard, and it is worth being clear-eyed about what they signal: 2.4M on find-skills signals default-install status, 479.9K on grill-me signals a workflow adopted on merit, and for a niche skill, a few thousand installs can mean complete saturation of the audience that matters. Stars, meanwhile, signal endorsement rather than use, which is why methodology repos dominate that chart. For a company, there is a quieter payoff than either number: a published, well-maintained skill in your domain is developer relations that works while you sleep, because every install is your expertise embedded in someone's daily agent.

One deliberate choice remains: public or private. Publish what markets your expertise; keep private what constitutes it. The procedures that differentiate your business belong in your organization's private skill layer (Claude enterprise skill distribution, or a platform-managed library like O-mega's private skills), not on a public leaderboard. The best operators do both, and the boundary between the two is a strategy decision, not a technical one.

20. The Models Running Your Skills in July 2026

Skills are instructions, and instructions are only as good as the model following them, so any skill ranking silently assumes a model lineup. Our January guide assumed one that no longer exists. As of July 2026, the Claude family that runs most skill-heavy workloads is: Claude Fable 5 (claude-fable-5, $10 input / $50 output per million tokens, 1M-token context, 128K max output, generally available since June 9, 2026), Claude Opus 4.8 ($5/$25, 1M context), Claude Sonnet 5 ($3/$15, with intro pricing of $2/$10 through August 31, 2026), and Claude Haiku 4.5 ($1/$5, 200K context), with Claude Mythos 5 remaining invitation-only under Project Glasswing - Claude model docs. On the OpenAI side, GPT-5.5 is the recommended frontier coding model in Codex, using fewer tokens per task than GPT-5.4 at equal per-token latency, with GPT-5.6 Sol announced for public preview on July 9, 2026 - NVIDIA blog.

The model-skill interaction has a shape worth internalizing: stronger models extract more from the same skill. A behavioral skill like grill-me produces sharper questions on Fable 5 than on a small model; a dense rule set like react-best-practices gets applied with better judgment about which rules bind in context. This cuts against the intuition that skills are a crutch for weak models. In practice the opposite holds: skills are leverage, and leverage scales with the strength of what it is applied to. The corollary is an economic one: the 1M-token contexts on Fable 5 and Opus 4.8 make large skill libraries nearly free to carry at discovery stage, while Sonnet 5's intro pricing makes skill-heavy bulk work (audits, migrations, batch document processing) cheaper than it has ever been. We benchmark the current lineup in our Fable 5 and Mythos 5 benchmarks guide, with deeper dives on Opus 4.8, Sonnet 5, and GPT-5.6's pricing and benchmarks.

Model choice per skill category, briefly: methodology and loop workloads (Superpowers, Ralph) want the strongest available model because judgment errors compound across iterations, and current Claude Code pricing tiers make that affordable on subscription rather than API metering, as we detail in our Claude Code cost breakdown. High-volume rule application (audits with web-design-guidelines, batch document work) runs well on Sonnet 5 and often on Haiku 4.5. The expensive mistake is the middle path: running long autonomous loops on a mid-tier model to save money, then paying the savings back in extra iterations and rework.

21. Future Outlook and Decision Framework

Standing where the ecosystem is in July 2026, four trajectories look structural rather than speculative. Consolidation onto the open standard completes: with 40+ clients, Microsoft-scale publishers, and install-tracked distribution, the SKILL.md format has crossed the threshold where network effects defend it, and competing proprietary formats now face the same headwind competing container formats faced after Docker won. The security arms race industrializes: instruction-level attacks will get scanning infrastructure (the arXiv wave is the research half of that industry forming), registries will add signing and provenance, and "who audits your skills" becomes a standard procurement question. The non-developer market overtakes the developer one: Cowork's 90% non-software usage share, multiplied by cloud and mobile availability, points the volume of skill execution firmly at office work. And private skill layers become the moat: as public skills commoditize general procedure, the compounding asset is the organization-specific library, which is why every serious agent platform, from Claude enterprise plans to O-mega, is building first-class private-skill infrastructure. The broader Anthropic platform context for these bets is mapped in our Anthropic ecosystem guide.

The decision framework, compressed. If you are new to skills: install find-skills, frontend-design, and grill-me, build one real thing, and add nothing else until you feel a specific gap. If you run a development team: adopt a behavioral base (grill-me plus tdd, or full Superpowers), add your stack's official vendor skills, mandate the section 15 vetting habit, and pin publishers. If you are responsible for security: treat skills as a package-manager surface today, deploy --safe-mode triage as standard procedure, and inventory what is already installed across your org, because after ClawHavoc the base rate of malicious packages is a known quantity, not a hypothetical. If you run a business function outside engineering: start with Anthropic's document skills in Cowork and encode one recurring workflow as a private skill this quarter; the compounding starts when the second workflow reuses patterns from the first. And if you want the workforce without the assembly: managed agent platforms bundle curated skills, execution infrastructure, and the security perimeter, which is the trade O-mega and its peers offer against the self-assembled stack this guide equips you to build.

The through-line from January to July is a lesson about this ecosystem's metabolism: in six months, the ranking authority changed, the top of the leaderboard rotated, an attack wave arrived, an official plugin absorbed the hottest community hack, and the addressable market quietly shifted from developers to everyone. A top-10 list in this space is a snapshot, not a canon. The durable skill is the meta one: check the leaderboard, read the SKILL.md, measure the before-and-after, and keep your own procedures encoded and versioned. Agents are becoming the workforce; skills are the training program. Run it deliberately.

Written by Yuma Heymans (@yumahey), founder and CEO of O-mega and co-founder of HeroHunt.ai, who has spent 2026 building skill libraries and autonomous loop infrastructure for AI agent workforces, including the skill-driven build system behind O-mega's agent platform.

This guide reflects the agent skills landscape as of July 8, 2026. Install counts, star counts, pricing, and model availability change quickly in this space: verify current figures before making purchasing or architecture decisions.