Claude Code plugins change everything. Here's how to actually install them.
I build Claude Code plugins. Hugin-v0 is mine — 23 skills, 13 agents, 8 event hooks, 7 MCP server integrations. Building it changed how I think about what AI tooling means, not in the abstract, but in practice.
Not AI that helps you type faster. AI that carries domain knowledge into every interaction.
That's what plugins do. They're not add-ons. They're context — structured, reusable context — that makes Claude operate with actual expertise rather than general competence.
What a plugin actually is
Without a plugin, Claude Code knows how to code. It's a generalist. Fast, capable, and occasionally wrong in ways that require you to know exactly where to look.
With a plugin, Claude operates inside a framework. Skills define how it approaches problems. Agents handle multi-step workflows. Event hooks fire at the right moments. MCP servers connect Claude to external tooling.
The difference between a generalist and a specialist isn't raw ability. It's judgment about when to apply what. Plugins give Claude that context.
And context, it turns out, is the hard part.
Installing one takes two commands
If you want something from the plugin marketplace:
/plugin marketplace add michelve/hugin-v0If you already know the package:
/plugin install hugin-v0@michelveThat's it. No setup wizard. No permissions flow. The plugin loads into the session, and the skills, agents, and hooks it defines become part of how Claude works with you from that point forward.
What actually changes after installation
Before: you write a prompt. Claude reasons through it from scratch, drawing on its training.
After: Claude enters the session with structured context. It knows what kind of problem you're likely working on. It applies skills matched to the task. It routes complex work through agents built for that specific workflow.
The prompt doesn't change much. The output changes significantly.
For a dev-focused plugin like hugin-v0, that means code reviews that apply real structural patterns — not style suggestions, but reasoned ones. Agents that handle multi-step refactors without losing thread. Hooks that fire when context shifts, so Claude stays oriented across long sessions.
The difference is qualitative. Not just faster. Better.
The part that surprised me
When I started building plugins, I expected writing the skills to be the hard part. They weren't.
The hard part was figuring out what made Claude's responses genuinely useful vs. technically correct. General competence is easy to get. Domain judgment is not. You have to encode the reasoning behind the right answer, not just the right answer itself.
That's also true from the user side. Installing a plugin takes seconds. Getting the most from it means understanding what kind of expertise it was built around — what assumptions the skills make, what workflows the agents expect, what the hooks are listening for.
That's not a limitation. It's the same learning curve as any good specialized tool. You can install a plugin and get better results immediately. Or you can understand it and get results that are different in character.
Why this matters now
Claude Code is already changing what individual developers can do. Plugins extend that in one specific direction: they let you encode the hard-won judgment of experienced practitioners into a reusable format.
That's not a metaphor. Skills are literally structured reasoning patterns, built from real patterns, applied consistently. They're someone's accumulated understanding of what good looks like in a specific domain — packaged so Claude can carry it into your work.
The shift from "Claude that codes" to "Claude with your team's actual expertise built in" is meaningful. Not every team needs it yet. But for the ones working on complex, domain-specific problems — the plugin ecosystem is where that becomes possible.
If you're curious what a plugin looks like from the inside, hugin-v0 is public and MIT-licensed. Install it, dig around, fork it.
That's also how I learned.