Top 5 Agent Skills Compared: The Pitfalls of Popularity Rankings and Selection Criteria

Agent skills are reusable work packages that enable AI agents to perform specific tasks consistently. They are broader in scope than simple prompts and can include not only instructions but also scripts, templates, examples, and reference materials.

This article analyzes five popular candidates presented as of August 10, 2026. However, because there is no raw data or point-in-time archive that would allow the exact figures in the provided materials to be independently reproduced, they should not be interpreted as a definitive “global usage ranking.”

What Are Agent Skills?

The core concept of Agent Skills, as described by Anthropic, is progressive disclosure. Instead of reading every work instruction from the outset, an agent first reviews the names and descriptions of skills, then identifies only those relevant to the current task and loads their main content and supporting materials.

A typical skill folder may contain the following elements:

• SKILL.md: The skill’s purpose, conditions for use, and work procedures
• Scripts: Tasks to be executed deterministically, such as validation, conversion, and generation
• Reference materials: API specifications, organizational policies, data structures, and domain knowledge
• Templates and examples: The desired output format and quality standards
• Evaluation materials: Test cases for comparing results before and after using the skill

Skills are not model training that teaches an agent new foundational capabilities. They are closer to context assets that provide task knowledge and procedures at execution time.

Differences from Prompts, Rules, and MCP

While MCP primarily addresses “what can be connected to,” skills explain “which procedures and standards should be used” with connected tools and materials. Rather than competing, the two technologies are complementary and can be used together.

How Should the Top 5 Ranking Be Interpreted?

The provided materials ranked the following five candidates by the number of stars on their GitHub repositories. However, GitHub stars are closer to indicators of interest and bookmarking; they do not directly measure downloads, active users, or task success rates.

The provided materials state that each repository has approximately 160,000–260,000 stars. To determine whether these figures refer to GitHub stars or installation totals from a particular registry, a GitHub API response or archived page from the same point in time would be required. Therefore, this article does not republish those numbers as verified current values.

Information Needed for a Reproducible Popularity Ranking

To create a reliable ranking, at least the following information should be disclosed together:

1. Measurement time and time zone
2. The repository’s exact owner, name, and commit SHA
3. Original responses for metrics such as GitHub stars, forks, and contributor counts
4. If installation counts are used, how duplicate installations and automated traffic are handled
5. The aggregation unit distinguishing entire repositories from individual skills
6. Rules for handling deleted or renamed repositories

In particular, if a single repository contains dozens of skills, repository stars alone cannot reveal which skills are popular. “Popular repositories” and “the most widely used individual skills” are different questions.

Design Philosophies of the Five Popular Candidates

1. obra/superpowers: Enforcing Process Before Implementation

superpowers has a strong workflow orientation designed to discourage agents from writing code immediately after receiving a request and instead require them to define the problem and develop a plan first. It centers on stages such as brainstorming, planning, test-driven development, debugging, and validation.

This approach is advantageous for tasks with unclear requirements or a high risk of change. By contrast, strictly applying the same process to clearly scoped tasks such as typo corrections may result in more questions and documentation than actual implementation.

2. Everything Claude Code: Providing a Bundled Development Environment

Everything Claude Code is a project that gathers various Claude Code configuration assets—including commands, agents, skills, hooks, and rules—in one place. It is useful for finding a broad range of examples spanning planning, implementation, review, testing, and record-keeping.

However, “install everything” is not necessarily the best approach. Similar rules may be duplicated, or different workflows may conflict. In actual adoption, it is safer to select only the components the current team needs and verify when each item is activated.

3. mattpocock/skills: Improving the Quality of Questions Rather Than Answers

A distinctive feature of this collection is that it provides not only output templates but also questioning procedures that help users clarify their thinking. It encourages users to surface goals, assumptions, edge cases, and success criteria before implementation.

The fact that source code is publicly available does not mean every file can be used freely for commercial purposes. Repository-level licenses may differ from separate conditions specified for particular directories or files, so the current license must be checked before actual copying, modification, or distribution.

4. andrej-karpathy-skills: Turning Concise Development Principles into Behavioral Rules

According to the provided materials, this project was created by a third party that organized development principles publicly discussed by Andrej Karpathy into a skill format. Its central ideas include thinking before coding, choosing simple solutions, modifying only the requested scope with precision, and setting verifiable goals.

The important point is to distinguish the source from endorsement. Using a famous person’s name or reformulating their public statements does not mean that person directly created the repository or guarantees its results. The original statements and the reformulator’s interpretation must be evaluated separately.

5. anthropics/skills: Examining Official Structures and Output Examples

Anthropic’s official repository is a starting point for examining skill directory structures and examples of work involving outputs such as documents, spreadsheets, presentations, and PDFs. It allows comparisons of how materials and scripts needed for actual file generation tasks are organized, beyond simple behavioral rules.

The number of SKILL.md files stated in the provided materials may vary depending on whether translations, duplicates, examples, and branches are included. To compare scale, files must be counted at a specific commit, and the criteria for identifying canonical versions must also be disclosed.

Three Principles Repeated Across Leading Skills

They Constrain Behavior Before Expanding It

Good skills do not indiscriminately expand what an agent can do. Instead, they control actions with a high probability of failure. Representative examples include not implementing before reaching agreement, not claiming completion without testing, and not modifying unrelated surrounding code that was not requested.

These constraints are not intended to eliminate agent autonomy. They are designed to reduce the cost of errors by placing checkpoints before actions that are difficult to reverse.

They Turn Expert Judgment Criteria into Procedures

The value of a skill lies less in sentence format than in decision-making criteria. By specifying the sequence in which experts confirm requirements, the way they handle uncertainty, and the standards they use to validate results, an agent can repeat similar reasoning procedures.

However, imitating a particular person’s writing style is different from reproducing a proven working method. Evaluation cases and failure conditions should be examined rather than names or authority.

They Confirm “Why” Before “How”

Code generation itself is becoming increasingly easy, but what should be built and what state should count as success are not determined automatically. This is also why the leading candidates focus on questions, planning, scope control, and validation.

Adding sophisticated implementation procedures without clear goals can result in solving a poorly defined problem more quickly.

Focus on Context Structure Rather Than Token Counts

The provided materials include examples in which some bundles use approximately 17,000–22,000 tokens per session. However, token counts vary depending on the following conditions:

• The model and tokenizer used
• The scope of activated skills, rules, and hooks
• Whether the client reads only metadata or injects the entire body
• The length of the conversation history and project instructions
• Whether caching and context compression are applied

Therefore, a specific figure cannot be generalized as a fixed cost across all installation environments. When measuring, use an empty session as the baseline and add skills one at a time while comparing input tokens, response latency, and task success rates together.

Practical ways to reduce context include the following:

• Separate organizational policies that are always required from task-specific skills.
• Include only the essential information needed for routing in skill descriptions.
• Move lengthy specifications and examples into separate files so they are read only when necessary.
• Consolidate overlapping rules into a single shared skill.
• Disable skills that are rarely used or have not demonstrated performance improvements.

Security and Supply Chain Risks Overlooked by Popularity Rankings

Skills may look like ordinary Markdown documents, but they can include shell commands, Python code, package installations, and external network requests. If an agent executes them, they create supply chain risks similar to those of ordinary software dependencies.

Before adopting an external skill, check the following:

1. Verify the repository owner and whether it is an official project.
2. Review installation scripts and executable files directly.
3. Check the permissions required for environment variables, authentication tokens, the home directory, and network access.
4. Pin the reviewed commit rather than using the latest state of a branch.
5. If possible, run it first in a container or restricted test environment.
6. Review the changes and any new permissions again before automatic updates.
7. Confirm that the license permits copying, modification, internal use, and commercial distribution.

Even a large number of GitHub stars does not eliminate the possibility of malicious changes, account compromise, or discontinued maintenance. Popularity is not a substitute for a security audit.

Criteria for Choosing Skills That Fit Your Environment

Popular repositories are best used as references for learning how to write skills, while production skills should be kept small and tailored to the organization’s codebase, review procedures, and tool permissions. Starting with a single recurring task and retaining only rules that pass evaluation is also advantageous for maintenance.

Conclusion

Although the five provided Top 5 candidates take different forms, they all encourage agents to confirm requirements, plans, scope, and validation before rushing into implementation. The key to their popularity lies less in adding numerous commands than in turning failure-prone decision points into procedures.

However, repository stars or registry installation counts alone cannot definitively identify the world’s most widely used individual skills. When citing rankings, the measurement time, original metrics, and aggregation units must be disclosed, while adoption decisions should be based on quality evaluation, context cost, licensing, and security review.