AI Skills Have Become Legendary, but a New Problem Is Getting Worse!

In January this year, I wrote an article specifically introducing AI Skills.

It mainly discussed several key questions: What are Skills? Where to find them? How to install them into AI Agents like Claude Code, Codex, Cursor, etc.?

At that time, Skills were still in a stage of rapid popularization. For most developers, finding a useful Skill and installing it into their Agent was enough to significantly improve the quality of AI output.

Now, just half a year later, thanks to the strong development of Agents and vibe coding gradually expanding to the masses, the situation has undergone earth-shaking changes. Skills have evolved from an initial AI concept to widespread adoption. Skills are no longer a niche tool for programmers; a variety of Skills with different functions have appeared on the market.

Excellent Skills in Various Fields

Frontend-related Skills were among the earliest popular Skills.

Official teams for Vue, React, and others have developed Skills for their respective ecosystems. Some component libraries, like antdv-next, have also launched supporting Skills to provide to Agents, facilitating more efficient and standardized development.

Beyond programming, many popular Skills have also emerged in office domains like imaging, writing, and PPT creation.

Photo Abstract Editorial

A Skill that transforms a photo into a vertical editorial piece consisting of an 'original photo area + abstract memory panel + poetic English title'.

guizang-ppt-skill

A web PPT skill adapted for Agent environments like Claude Code/Codex, used to generate single-file HTML horizontal-flip PPTs, PPT illustrations, and multi-platform covers, with a built-in complete rehearsal and presenter mode.

The PPT effects produced by this Skill are already comparable to commercial-grade presentation PPTs.

The endless stream of Skills has well illustrated the statement we made at the beginning: Skills are the ability to precipitate experience and best practices into AI capabilities, turning 'knowing' into 'doing'.

Furthermore, domestic giants like Tencent have even launched a dedicated Chinese Skills platform: skillhub.

New Problems

But as usage time grows, new problems begin to emerge.

We are using more and more Agents, and installing and writing more and more Skills:

• One set in Codex
• One set in Claude Code
• Possibly another set in the Cursor project directory

We are handling more and more things, and the roles of Skills are gradually differentiating:

• Some are globally effective
• Some belong only to a specific project
• Some are for development
• Some are for office work
• Some are installed from GitHub
• Some are maintained by individuals or teams

When one Skill is modified, you also need to consider whether copies in other Agents need synchronization.

When changing computers, you have to reorganize and restore the original Skills environment. Skills are scattered everywhere, in a chaotic mess.

This indicates:

Skills solved the problem of 'whether AI can do it', but when there are more and more Skills, we also need to solve the problem of 'how to manage them'.

To address these pain points, an open-source Skills and MCP Server desktop management tool, SkillBuddy, was born.

GitHub: https://github.com/konnga/skill-buddy

More and More Agents, Skills Scattered Everywhere

Nowadays, it's common to work with multiple AI Agents simultaneously.

Developers might use different Agents in various scenarios:

• Claude Code
• Codex
• Cursor
• Gemini CLI
• GitHub Copilot
• Trae
• OpenCode
• CodeBuddy
• WorkBuddy

Different Agents have their own positioning, models, and interaction methods, but their Skills are usually stored in their respective agreed-upon directories.

When using only one Agent and installing three to five Skills, managing folders directly isn't a problem. But once the number of Agents and Skills increases, things aren't so simple.

You might encounter these situations:

• Not knowing how many Skills are installed on the computer in total;
• Not knowing which Agents a certain Skill is installed in;
• The same Skill being copied to multiple directories, occupying multiple independent copies;
• After installing a new Agent, needing to find and install common Skills again;
• Global Skills and project-level Skills mixed together;
• A Skill no longer in use left in some corner, only discovered much later.

Folders can only tell users 'where files are placed', but they struggle to answer 'what capabilities are currently available'.

This is the first obvious management pain point: Many Agents, but lacking a unified Skills view for management.

What's Missing Isn't Another Skills Market, but Visual Management

There are already channels like skills.sh, skillhub, and GitHub to help us discover Skills, and command-line tools to help users complete installations.

They solve the problems of 'where to find' and 'how to install' very well.

But during long-term use, users also need to know:

• What does this Skill do?
• Where does it come from?
• Which Agents is it installed in?
• Does it belong to the global scope or project scope?
• Is it currently enabled?
• Is the content of Skills with the same name in multiple Agents consistent?
• Which Skills are my own, and which come from plugins or the system?

When Skills grow from a few to dozens or even more, continuing to rely on the command line and file directories will gradually lose the overall perspective.

A more ideal way is to provide a workbench similar to a package manager, where you can see all local Agents, Skills, installation locations, and statuses upon opening it. SkillBuddy is designed for this purpose.

After starting, SkillBuddy automatically detects locally installed Agents and scans their Skills directories. Skills from different Agents, global scopes, and project scopes are aggregated into a single interface.

You can browse Skills in a list or grid view, viewing descriptions, sources, installation locations, and content without needing to open hidden directories one by one.

Why Do Multiple Versions of the Same Skill Appear?

Installing a Skill into multiple Agents essentially means saving copies of it in multiple directories.

When first installed, their content is identical. But after a period of use, the following situation easily occurs:

1. The Skill rules in Codex are modified;
2. Claude Code still retains the old content;
3. Cursor's project directory has a version adjusted for the current project;
4. The file names in the three directories are the same, but the content is already different.

This type of problem can be called Skills content drift.

It's harder to detect than 'whether it's installed'. Because from the file name, everything seems normal. Only when actually comparing file contents can you discover they are no longer the same Skill.

SkillBuddy aggregates Skills with the same name from different Agents and alerts users to content inconsistencies. Users can view differences, choose a trusted version as the baseline, and then synchronize it to other targets.

This means Skills management is no longer just about copying files, but also includes:

• Identifying duplicate copies;
• Detecting content differences;
• Determining which version is the baseline;
• Previewing the synchronization scope;
• Distributing confirmed content to other Agents.

Global Skills and Project Skills Should Also Be Managed Separately

Not all Skills are suitable for global installation.

For example:

• Vue 3 general development standards can serve as personal global Skills;
• A company's interface conventions are only suitable for that company's projects;
• A repository's directory structure and business rules should only follow the current project;
• Temporary experimental rules might only be used in one project for a few days.

If all Skills are placed in the global directory, the Agent will receive more and more information unrelated to the current task. If all are placed in projects, there will be a lot of duplicate configurations.

Therefore, Skills management needs to clearly distinguish:

• User-level Skills: Personal, reused across multiple projects;
• Project-level Skills: Follow the repository, serving only specific projects;
• Plugin or System Skills: Maintained by external tools, usually should not be modified arbitrarily.

SkillBuddy can add project directories, scan Skills within projects, and display them separately from user-level Skills.

In this way, what users see is no longer a pile of contextless files, but a set of AI capabilities with sources and scopes of effect.

One Skill Isn't Enough; Managing 'Skill Packs' Is More Necessary

In real projects, developers rarely rely on just one Skill.

Taking a Vue project as an example, a complete set of development capabilities might include:

• Vue 3 Best Practices;
• Vue Router Usage Standards;
• Pinia State Management Standards;
• VueUse Composable Function Standards;
• Component Testing Standards;
• UI Component Library Standards;
• The project's own code and design standards.

If you have to find, select, and install each one individually every time you create a project, not only is the operation repetitive, but it's also easy to miss one.

This is very similar to dependency management in a development environment: what ultimately needs to be managed is not isolated tools, but a reusable combination of capabilities.

Therefore, SkillBuddy supports combining multiple Skills into skill packs for:

• Saving commonly used personal development combinations;
• Installing to multiple Agents at once;
• Quickly configuring a set of Skills for new projects;
• Importing, exporting, and sharing combinations;
• Batch enabling or managing related Skills.

You can establish:

• Vue Frontend Skill Pack;
• React Performance Optimization Skill Pack;
• UI Design Review Skill Pack;
• Node.js Backend Skill Pack;
• Code Review Skill Pack;
• Exclusive skill packs for specific roles or projects.

Only when Skills can be organized and reused will they gradually evolve from 'a few prompt files' into a true capability system.

Personal Skills and Team Skills Are Two Different Problems

When using Skills personally, users are more concerned about:

• What is installed;
• Which Agents can use them;
• How to migrate between multiple computers;
• How to back up self-written Skills;
• How to keep multiple copies consistent.

Therefore, SkillBuddy supports backing up personal user-level Skills and skill packs to a private Git repository. When changing computers, you can preview the remote content and installation targets before deciding which resources to restore.

But team management is a problem on a completely different level.

A team cannot directly distribute unconfirmed Skills to all members. It typically needs to consider:

• Which Skills have passed team review;
• Who can maintain and publish Skills;
• How to record each modification;
• Which Skills should different roles install;
• How new members can quickly acquire standard capabilities;
• Whether Skills required by the project are missing or outdated;
• How to block MCP configurations that do not meet security requirements.

Simply putting files into a shared directory cannot solve these problems.

SkillBuddy's team library uses a Git repository as the source of truth. Teams can manage reviewed Skills, MCP definitions, role-based skill packs, and project policies in the repository, continuing to leverage Git's existing branching, committing, and Pull Request review processes.

Personal Skills can be freely experimented with, while team Skills need to be reviewable, traceable, and distributable. Separating the two is a necessary step when a team truly adopts Skills.

Beyond Skills, MCP Servers Are Facing the Same Problem

In previous articles, MCP has been introduced. It allows AI applications to connect to external tools and data using a unified protocol.

But in local use, MCP Server configurations are similarly scattered across different Agents.

Each Agent's configuration file, field format, and supported capabilities may differ. Users need to deal with commands, parameters, environment variables, remote addresses, and enablement statuses, making it hard to quickly confirm where a certain MCP Server is currently installed.

Therefore, SkillBuddy also scans and aggregates local MCP Servers:

• View MCP Server configurations and installation targets;
• Manage enable/disable statuses;
• Synchronize configurations to other supported platforms;
• Preview configuration files to be written before modification;
• Verify whether the target platform supports the corresponding capabilities;
• Avoid saving plaintext Tokens and passwords in team resources.

SkillBuddy manages not just one type of file, but the entire set of local capabilities that developers hand over to AI.

How Does SkillBuddy Work?

SkillBuddy does not create a new Skills format, nor does it require Agents to run Skills through SkillBuddy.

It directly reads the local directories originally used by each Agent and, upon user confirmation, writes content to the user-selected target location.

It can be understood as a management layer sitting above different Agents:

                  SkillBuddy
                       │
        ┌──────────────┼──────────────┐
        │              │              │
  Claude Code        Codex          Cursor       ...
        │              │              │
   Their original Skills & MCP config directories

Even if you stop using SkillBuddy, the installed Skills remain in the Agent's original directories and will not be locked into a proprietary platform.

Currently, SkillBuddy has built-in support for the Skills directory conventions of the following Agents:

• Claude Code
• Codex
• Cursor
• OpenCode
• GitHub Copilot
• Gemini CLI
• CodeBuddy
• Trae / Trae CN
• WorkBuddy
• Doubao
• Kimi Code
• Z Code
• ...

The list is still expanding, and of course, you can add other Agents through custom directories.

Why Choose a Desktop Application?

Skills and MCP configurations are primarily local files.

If you need to scan directories of multiple Agents, compare file differences, manage project-level resources, and open local installation packages, a desktop application is more suitable than a pure web page.

SkillBuddy adopts a local-first approach:

• No SkillBuddy account registration required;
• Scans and manages local files by default;
• Only modifies targets explicitly selected by the user;
• Private Git repository authentication is delegated to the system Git, SSH Agent, or credential manager;
• Does not save Git repository passwords;
• Git backups will not include MCP configurations, Tokens, local absolute paths, and project-level Skills.

Of course, the ability to operate on local files also means the tool must be more cautious. SkillBuddy validates manageable paths in the main process, refuses to write to locations outside managed directories, and tries to display targets and specific operations before batch changes.

Current Version and Some Limitations

SkillBuddy is currently in a public preview stage, and many details still need further refinement.

The following installation packages are currently available:

• macOS Apple Silicon: DMG, ZIP;
• Windows x64: EXE, ZIP;
• Windows ARM64: Preview version;
• Linux x64: AppImage, DEB, RPM;
• Linux ARM64: Preview version.

Intel Mac is currently not supported.

Download and Experience

SkillBuddy is already open-sourced on GitHub under the MIT license.

• GitHub: https://github.com/konnga/skill-buddy
• Download: https://github.com/konnga/skill-buddy/releases
• Feedback: https://github.com/konnga/skill-buddy/issues

After installation, you can try this shortest experience path first:

1. Open SkillBuddy and view the automatically detected Agents;
2. View the existing user-level Skills on your machine;
3. Add a project directory and check project-level Skills;
4. Select a Skill and view its installation status in different Agents;
5. Try installing or synchronizing it to another Agent;
6. Save several commonly used Skills as a skill pack.

The Next Step for Skills Is Moving from 'Installation' to 'Management'

Initially, we focused on how to give AI new capabilities.

But when these capabilities grow in number, the new problem becomes: How can we truly manage them well?

As the number of Agents increases, the Skills ecosystem is likely to continue expanding. Developers need more high-quality Skills, but also need to solve problems like visualization, scope of effect, version drift, skill packs, backup migration, and team collaboration.

SkillBuddy is an open-source attempt to address this problem.

It is still in its early stages. If you are also using Claude Code, Codex, Cursor, or other AI Agents, you are welcome to experience SkillBuddy and share: https://github.com/konnga/skill-buddy

What other problems have you encountered when managing personal or team Skills?