'Skills' and 'Plugins' have different meanings.
These terms are often used loosely. One person in a software development forum might say 'install a GitHub plugin,' another might say 'I've written a skill for that,' and it's not always clear whether they're describing the same type of task.
In the Claude Code ecosystem , they are not the same. Skills and Plugins have distinct shapes, editing models, and tasks. Confusing them leads to building things you don't need to build, or searching for configuration files when you should be installing a package.
This article will analyze exactly what each type is, how they differ, and the practical question of whether you should build your own Claude Code skill or use a pre-packaged plugin.
What exactly are Claude Code Skills?
A skill in Claude Code is a user-written instruction – something you write to tell Claude how to handle a specific, repeatable task in your particular context.
The most concrete form of a skill is a custom slash command. You create a Markdown file inside the .claude/commands/ directory (or in the ~/.claude/commands/ directory for use between projects), and that file becomes a callable command in your Claude session.
What exactly are Claude Code Plugins?
A plugin is a packaged capability that someone else has built and provided for installation. Instead of writing instructions, you are adding a new tool or a set of tools to the Claude Code environment.
The main plugin mechanism in Claude Code is MCP — Model Context Protocol. MCP is an open standard that defines how AI systems can connect to external tools, data sources, and APIs. An MCP server provides capabilities that Claude can call: reading databases, searching the web, posting Slack messages, and querying APIs.
The core differences between Claude Code Skills and Plugins
The decision isn't always about choosing one or the other. A complete Claude Code setup typically includes both: project-specific skills that fit your team's workflow, plus plugins for external systems like GitHub, databases, or web search.
When should you create a skill?
Develop a skill when the task requires specific knowledge within your context—knowledge that a readily available tool cannot provide.
Your team has repetitive workflows.
If your team performs the same multi-step task more than twice a week, that's a candidate for Skills. Code review checklists, deployment steps, crash report templates, database migration models — these are things Claude won't know unless you tell him.
A well-written skill will transform that internal knowledge into a callable command. New engineers will benefit immediately; experienced ones will stop doing repetitive tasks.
The task requires specific context of the project.
Some tasks only make sense within your project architecture. Writing a new API endpoint 'the right way' means following your conventions, not a generic template. Writing tests means using your test support tools, factories, and mockups.
The CLAUDE.md skills are particularly useful here. They provide all the necessary context that would otherwise require a lengthy, multi-line explanation at the beginning of each session.
You need precise and predictable behavior.
Plugins provide what they display. Skills provide exactly what you write. If you need Claude to adhere to a specific output format, check specific files, or apply specific rules, then a skill is more reliable than hoping a plugin will work the way you want.
Signs that indicate you should create a skill
- You find yourself typing the same block of context at the beginning of each work session.
- A clearly defined but specific task for your domain or codebase.
- No existing plugin does exactly what you need.
- The task does not require calling external APIs — it's purely logic or code manipulation.
When should you install plugins?
Install a plugin when you need to access something that's outside the native capabilities of Claude Code — and someone else has already done the integration work.
APIs and external services
Claude Code cannot communicate with GitHub APIs, your database, or Slack without a bridge. MCP plugins are that bridge. If you need Claude to query a Postgres database, read issues from GitHub, or search the web in real time, the plugin is the right solution.
Building your own isn't wrong, but you'll essentially be writing an MCP server from scratch. For well-supported external services, someone has almost certainly already built it.
Versatile capabilities you'll reuse everywhere.
Some useful capabilities for any project include: web search, file system access with restricted permissions, and browser automation. These capabilities don't need to be customized for each project. Install once, configure access permissions, and use them everywhere.
Time is a crucial factor.
If you need a feature immediately and someone has already packaged it well, installing a plugin is faster than writing a skill. A plugin with good documentation will be ready to use in minutes. Writing a skill requires task clarity, drafting, iteration, and testing.
Signs that indicate you should install a plugin.
- You need to call an API or external service.
- That function is general in nature — web searching, database querying, file access.
- A well-maintained package already exists.
- You don't need to customize how that function works internally.
Use Skills and Plugins together.
The most effective Claude Code setups utilize both — and they are designed to complement each other.
A typical example:
- Install plugins for the infrastructure — access GitHub, query the database, search the web. These are the building blocks.
- Write skills for workflows — custom slash commands combine those functions into task-specific sequences. A /fix-bug skill might search the web for document context, query the database schema, and write a fix according to your team's conventions.
Think of plugins as tools in a toolbox and skills as instructions on how to use those tools to build something specific for your project.
You can also write skills that explicitly reference capabilities provided by plugins. A CLAUDE.md instruction like 'when debugging, use the Postgres MCP tool to inspect query logs instead of directly reading log files' would link the workflow you wrote to an installed capability.
Build your own plugin
There's a third option worth mentioning: Building your own MCP server. This makes sense when:
- You have internal APIs that are not included in any public plugins.
- You want to share a set of capabilities with your entire team or organization.
- You are building something general enough to be packaged but specific enough that no public plugins exist.
Building an MCP server is more complex than writing a slash statement—it requires setting up a separate process. But the Model Context Protocol documentation is well-maintained, and there are SDKs for Node.js, Python, and several other languages.