I have skills scattered across four different directories. There’s a ~/.claude/skills folder for Claude Code. ~/.codex/skills for Codex. ~/.cursor/skills for Cursor. You get the idea.
Every time I find a useful skill on GitHub, I have to clone it into multiple places. Or pick one tool and accept that the skill won’t be available in the others. Neither option feels great.
I built Skillsync to fix this.
What’s the Actual Problem
The background: AI coding tools—Claude Code, Cursor, Codex, Windsurf—have all added support for “skills.” Skills are little packages of knowledge that teach these tools how to do specific things. How to work with a particular framework. How to format code a certain way. How to interact with a specific API.
The idea is great. The implementation, less so.
Each tool decided on a different directory structure. Some use ~/.toolname/skills, others use ~/.toolname/skills/SKILLNAME. There’s no standard. No compatibility. If you use multiple tools—which many of us do—you end up duplicating everything.
I wanted something like: configure once, sync everywhere.
How It Works
Skillsync is a command-line tool. You tell it where your skills come from, and it copies them to wherever they need to go.
Sources can be:
- GitHub repositories (you can specify subdirectories if needed)
- Local folders (for your own skills)
Targets are the AI tools you use:
- Claude Code
- Cursor
- Codex
- Windsurf
- And others that use compatible structures
You add a source once, and Skillsync remembers it. Then when you run skills fetch, it pulls the latest version from all your sources. And when you run skills sync, it copies everything to all your targets.
That’s the whole idea.
Using It in Practice
Here’s what my workflow looks like.
I find a skill I want on GitHub. Let’s say it’s Vercel’s agent-skills repository. I add it as a source:
skills source add vercel-labs/agent-skills --subdir skillsThe --subdir part is there because GitHub repos often have skills in a subdirectory, not at the root.
Then I fetch:
skills fetchThis clones or updates the repository. Skillsync keeps track of what’s been downloaded.
Then I sync:
skills syncThis copies all the skills to all my enabled targets. I’ve set up Claude and Cursor as targets, so it copies to both.
After that, the skills are available in both tools. I don’t have to think about it again until I want to update.
What This Actually Solves
Before Skillsync, whenever I found a useful skill, I had to decide: do I use it in Claude? Or Cursor? Or manually clone it to both?
Usually I’d pick one tool and live with the limitation. Or I’d clone it manually to both, and then I’d have to remember to update both when the skill changed.
Neither is great. The first limits what I can do. The second is maintenance overhead.
With Skillsync, I just add it once. I don’t have to think about where it lives or which tools can use it. It’s just available everywhere.
The difference isn’t dramatic. It’s not life-changing. But it removes friction. And those small frictions add up.
What Doesn’t Work Well
I should be honest about the limitations.
Updates aren’t automatic. You still have to run skills fetch and skills sync manually. I’ve thought about adding auto-sync or watching for changes, but that adds complexity. For now, manual is fine.
Conflicts can happen. If you have a skill with the same name from two sources, Skillsync has to pick one. It warns you, but you might not notice until something breaks.
Some tools have quirks. Not all AI tools implement skills the same way. Some expect certain file structures. Some have bugs in how they load skills. You might hit edges depending on what tools you use.
It’s another tool to maintain. You have to install it, keep it updated, learn its commands. That’s overhead. For me, it’s worth it. For someone who only uses one AI tool, it probably isn’t.
Why I Built It
There’s a meta-point here about tool fragmentation.
As AI coding tools have proliferated, each one has been building its own ecosystem. Its own package format. Its own directory structure. Its own way of doing things.
This is predictable—every company wants to be the platform. But from a user perspective, it’s annoying. I don’t want to care about which tool I’m using. I just want my skills to be available.
Skillsync is my attempt to paper over this fragmentation. It doesn’t solve the underlying problem—these tools still don’t agree on standards. But it makes the problem livable.
I suspect in the long run, either:
- One tool wins and everyone else adopts its format, or
- The tools converge on a standard
Until then, we need glue like Skillsync.
If You Want to Try It
It’s a Node package. Install with:
npm install -g skillsyncThen:
# Add your first source
skills source add anthropics/skills
# Fetch skills
skills fetch
# See what you have
skills ls
# Sync to your tools
skills syncBy default, it syncs to common tools it can find on your system. You can customize targets with skills target add and skills target remove.
There’s more documentation in the repo if you need it.
The Bigger Picture
What I’m interested in is how this space evolves.
Right now we’re in the chaotic phase of a new technology. Every tool is inventing its own conventions. Users are dealing with fragmentation. Hackers are building glue to make things work.
Eventually, things will settle. Standards will emerge. Or winners will take all.
Until then, tools like Skillsync are stopgaps. Not solutions, but ways to make the transition less annoying.
I’m okay with that. Not every tool needs to be revolutionary. Some just need to make your day slightly less frustrating.
Skillsync is open source. If you deal with the same skills fragmentation, give it a try. And if you find bugs or have ideas for improvements, issues and PRs are welcome.