AI Agents Have No Package Manager. That's the Real Bottleneck.

Every developer has npm. Every Python dev has pip. And everyone building with AI agents has... a folder of markdown files they copy between machines and hope they still work.

The Moment I Realized Something Was Broken

I was setting up a new laptop.

Not a dramatic story. But somewhere between installing Claude Code, wiring up Cursor, and getting Codex talking to my repos, I hit the wall that every person working seriously with AI agents eventually hits: none of my skills came with me.

The Figma-to-prompt skill I built and wrote about. The one that audits portfolio case studies. The CV builder. The half-dozen small, boring, incredibly useful skills that turn a general-purpose model into something that actually knows how I work. All of them were sitting in a directory on my old machine, in a structure only I understood, with no versioning, no dependencies, no way to say "give me the setup I had three weeks ago."

So I did what everyone does. I opened a Finder window, dragged folders around, fixed the paths that broke, and lost about two hours.

Then I did it again a month later when a friend asked me to share my setup, and the honest answer was "I'll zip it and send it to you, good luck."

That's the moment. Not a product insight, not a market gap on a whiteboard. Just the specific irritation of realizing that the most powerful thing I'd built in two years of working with AI was also the least portable thing I owned.

What Skills Actually Are (And Why Nobody Has Solved This Yet)

If you're not deep in this world, a quick reframe.

A "skill" is a packaged instruction set that changes what an AI agent can do. It might be a structured prompt with a defined workflow. It might be a tool definition. It might be an MCP server that connects your agent to Figma, or Slack, or your database. Whatever the form, the effect is the same: it takes a general model and gives it a specialty.

Skills are the reason my Claude Code setup produces different, better output than yours running the same model. Not because the model is different. Because the accumulated context is.

Here's the problem. That accumulated context is the single most valuable asset in your AI workflow, and it currently lives in the worst possible place. Scattered local directories. Gists. Screenshots of prompts in Slack threads. A Notion page you haven't updated since March.

And it fragments further with every tool you add. Claude Code has its skill format. Cursor has its rules. Codex has its own conventions. Gemini CLI does its thing. The concepts map onto each other almost perfectly, but the plumbing doesn't — so most people just pick one agent and pretend the others don't exist.

That's not a technical limitation. That's a missing layer.

Software had exactly this problem before package managers. Everyone wrote good code, nobody could find anyone else's good code, and the same solutions got rebuilt ten thousand times in parallel. npm didn't make JavaScript better. It made JavaScript cumulative. That's a different and much bigger thing.

AI agent skills have been stuck in the pre-npm era. Enormous individual value, near-zero collective value, because there was no shared surface where the value could compound.

SkillsCenter

So I built SkillsCenter. The tagline is deliberately unsubtle: npm install, but for AI skills.

It does three things, and I want to be precise about them because the interesting part isn't the feature list — it's why these three and not others.

It indexes what already exists

There are 1,038 skills in the catalog right now. Prompts, tools, MCP servers, all built by the community and all searchable in one place.

That number matters less than what it represents. Before you can share anything, someone has to be able to find it. The catalog is the boring infrastructure layer, and it's the part I spent the most time on, because a package manager where discovery doesn't work is just a slower way to download files.

What surprised me while building the index is how much good work is already out there and how invisible it is. Sophisticated, well-designed skills sitting in repos with eleven stars, solving problems that hundreds of people are solving badly right now, because there was no place where "I need a skill that does X" and "I built a skill that does X" could ever meet.

It tracks what's installed, across every agent

This is the part I built for myself first.

One dashboard showing which skills are live in Claude Code, which are in Cursor, which are in Codex, which are in Gemini CLI. Not four separate mental models. One.

The multi-agent thing isn't a checkbox feature — it's the actual thesis. I don't believe anyone reading this is going to use exactly one AI tool for the next five years. The tools are moving too fast and each one is genuinely better at something. Making skills portable across agents isn't a convenience. It's what makes the whole ecosystem non-hostage.

It lets you publish your setup, and clone someone else's

Publish your skillset. Follow other developers. Replicate any agent config in one command.

You find someone whose work you respect, whose output is consistently sharper than yours in some domain, and instead of reverse-engineering their process from their tweets, you just install their configuration and start from where they are.

That's what social package management looks like when it works. Not "look at my repo," but "run this and you have what I have."

Why a Designer Built Developer Infrastructure

I'll address the obvious thing.

I've spent 16 years as a product designer. I am not the person you'd expect to ship a package manager. And for most of the last two years, the tooling I built for myself stayed for myself, because there's a voice that says infrastructure is somebody else's job.

What changed is that the gap between having an idea and having a working thing collapsed. The same skills-and-agents workflow I was frustrated about is the thing that let me build the fix for it. That's a genuinely strange loop and I don't think we've fully absorbed what it means yet.

But there's a second reason, and it's more to the point.

This is a design problem wearing developer clothes. The technical challenge in SkillsCenter is real but not exotic. The hard part is everything around it: what a skill's page needs to show for you to trust it in ten seconds, how discovery works when users don't know the vocabulary for what they need, how you make "clone this person's setup" feel safe rather than reckless, what the empty state says to someone who has never installed a skill.

Package managers are famously bad at this. They're built by people optimizing for correctness, and correctness is necessary but it's not the thing that makes someone come back. So the honest answer to "why did a designer build this" is that I don't think it would have been built the way it needed to be built otherwise. Not better — different, in a way that mattered here.

What I Actually Think This Becomes

I'll be careful not to oversell.

Right now SkillsCenter is a catalog, a tracker, and a publishing surface. That's useful. It's not yet the thing I think it should be.

What I'm actually building toward is the point where your agent configuration becomes a first-class, versioned, shareable artifact. Where the answer to "how do I get good at working with AI" isn't "spend two years accumulating tacit knowledge in a private folder," but "start from a strong baseline that a thousand people improved before you touched it."

That's the npm lesson again. The value of npm was never the registry. It was that JavaScript developers stopped starting from zero. A junior dev in 2015 shipped things a senior dev in 2010 couldn't — not because they were better, but because they inherited more.

We are about to find out what that looks like for AI capabilities. My bet is that it's the difference between AI being a tool that makes individuals faster and AI being something that makes an entire field cumulative.

Try It

The catalog is live at skillscenter.dev. Creating an account is free, browsing doesn't require one.

If you've built skills you're proud of, publish them. If you've been rebuilding the same workflow from scratch on every new machine, this is the thing that stops that.

And if you install something and it's rough, tell me. It's early and I'd rather hear it now.