We used to share code. Now we share intent.
For years, our industry has been built around one core idea: reuse.
npm packages, shared libraries, frameworks — all ways to take someone else's solution and plug it into our own system.
It worked. It scaled. It shaped how we build software.
But there's always been a hidden cost.
When you import a package, you're not just importing functionality — you're importing decisions.
Architecture choices, naming conventions, constraints, trade-offs made by someone else, often in a different context.
Sometimes that's exactly what you want.
Other times, it's friction you carry for the lifetime of your product.
From code to knowledge
I've been thinking about this a lot lately, especially with the rise of AI in our workflows.
And I keep coming back to the same idea: AI skills are becoming the new npm packages.
But instead of distributing opinionated implementations, we're starting to distribute something more flexible — and arguably more valuable: expertise.
An AI skill doesn't give you code to reuse.
It gives you a way to think.
It captures how someone approaches a problem — the constraints they consider, the trade-offs they make, the patterns they recognize — without forcing you into a specific stack or architecture.
That's a very different kind of abstraction.
We're moving from sharing solutions to sharing reasoning.
Why this shift matters
With traditional packages, reuse comes with coupling.
You gain speed, but you inherit structure, opinions, and implementation.
With AI skills, the relationship flips.
You still benefit from someone else's experience, but you stay in control of the implementation. The output adapts to your context — your codebase, your constraints, your product.
This decoupling is subtle, but powerful.
It means that expertise becomes portable in a way it never really was before.
Not as blog posts.
Not as documentation.
But as something you can actually use in your daily work.
What this looks like in design systems
This shift becomes very real when you look at design systems.
Traditionally, a design system is distributed as a set of components, core elements, and guidelines. You build a system, document it, and teams consume it.
The true value of a design system lies not simply in the sum of its individual parts.
It's the decisions behind them.
Why a component behaves a certain way.
Why a pattern exists.
When to use it — and when not to.
Those things are hard to encode in code, and this is where AI skills start to change the game.
Imagine a design system not just as a static library, but as a skill you can query.
Instead of browsing documentation, a developer could ask:
"Generate a table component API consistent with our system, including accessibility constraints and edge cases."
Instead of manually reviewing UI, you could run a skill that analyzes a screen and flags inconsistencies with your design tokens, spacing rules, or interaction patterns.
Instead of onboarding someone through pages of docs, you could have a skill that explains your system in context — why things are built the way they are, not just what exists.
In all these cases, you're no longer distributing just the output of the system.
You're distributing the thinking behind it.
A different kind of reuse
What's interesting is that this doesn't replace traditional systems — it complements them.
You still need components.
You still need code.
But now there's another layer on top: a layer where knowledge itself becomes reusable.
And that changes the nature of what we build and share.
As someone working in UI and design systems, this feels particularly relevant.
Because so much of the work has always been about decisions, consistency, and trade-offs — things that don't live comfortably in code alone.
AI skills give us a way to package that part of the work.
Not without risks
Of course, this isn't automatically better.
A poorly designed skill can be just as harmful as a poorly designed library — maybe even more, because it's less visible.
There's also a real risk of superficial outputs if the underlying thinking isn't solid.
And we're still relying on models we don't fully control.
So this isn't about replacing engineering discipline with prompts.
It's about adding a new layer — one that needs just as much care, if not more.
Closing thought
NPM packages helped us scale our code, while AI skills could help us scale our thinking.
This represents a deeper shift than it initially appears.
We're not just sharing what we build anymore.
We're starting to share how we think.
Top comments (0)