If you’ve been building with Claude Code, you’ve probably seen the terms “skill,” “plugin,” and “agent” thrown around. They’re related but distinct concepts, and understanding the difference will help you build better tooling. Let’s focus on skills versus plugins since those two are the most closely related.

Skills: Reusable Slash Commands

Skills are user-invocable slash commands, essentially reusable prompts that run directly in your main conversation. You trigger them with /skill-name and they execute inline. They can be workflows or common tasks that are done frequently.

Skills can live inside your .claude/skills/ folder, or they can live inside a plugin (where they’re called “commands” instead). Same concept, different home.

The important frontmatter you should pay attention to is the allowed-tools property. This defines which tool calls the skill can access, and there are three formats you can use:

1. Comma-separated names — Bash, Read, Grep
2. Comma-separated with filters — Bash(gh pr view:*), Bash(gh pr diff:*)
3. JSON array — ["Bash", "Glob", "Grep"]

I don’t think there’s a meaningful speed difference between them? The filtered format might take slightly longer to parse if you have a huge list, but in practice it’s negligible. Pick whichever is most readable for your use case.

The real power here is that skills can define tool calls and launch subagents. That turns a simple slash command into something that can orchestrate complex workflows.

Plugins: The Full Package

A plugin is a bigger container. It can bundle commands (skills), agents, hooks, and MCP servers together as a single distributable unit. Every plugin needs a .claude-plugin/plugin.json file; which is just a name, description, and author.

Plugins are a good way to bundle agents with skills. If your workflow needs a specialized agent that gets triggered by a slash command, a plugin is a good option for that.

Pushing the Boundaries of Standalone Skills

However, I wanted to experiment with what’s actually possible using standalone skills, so I built upkeep. It turns out that you can bundle actual compiled binaries inside a skill directory and call them from the skill. That opens up a lot of possibilities.

Here’s how I did it:

• The skill has a prerequisite section that checks for a bin/ folder containing the binary
• A workflow calls the binary, passing in the commands to run
• Each step defines what we expect back from the binary

You can see the full implementation in the SKILL.md file. It’s a pattern that lets you distribute real functionality, not just prompts, through the skill.

Quick Summary

• Skills are slash commands. Reusable prompts with tool access that run in your conversation.
• Plugins bundle skills, agents, hooks, and MCP servers together with a plugin.json.
• Skills are more flexible than you might expect, you can call subagents, distribute binaries, and build real workflows.

If you’re just getting started, skills are the easier entry point. When you need to package multiple pieces together or distribute agents alongside commands, that’s when you reach for a plugin.

Have fun building!