Welcome to Skills, Plugins & CLI Automation! In this course, you'll learn how to extend Claude's capabilities, package those extensions into shareable components, and automate your workflows through command-line interfaces.

Skills are like custom modes for Claude. Instead of telling Claude "explain this code with diagrams and analogies" every time, you create a Skill once, and Claude switches into that mode automatically when needed. Think of it like having different tools in a toolbox — you pick the right one for the job.

Plugins bundle multiple Skills together so you can share them with your team. It's like creating a recipe book instead of individual recipes — everything packages up nicely for others to use.

CLI automation lets you trigger Claude with specific Skills from scripts and build processes, turning manual workflows into automatic ones.

This lesson focuses on creating Skills and understanding how they work.

Every Skill lives in a folder containing SKILL.md. Where you put that folder determines who can use the Skill:

Personal Skills (~/.claude/skills/<skill-name>/SKILL.md): Available across all your projects Project Skills (.claude/skills/<skill-name>/SKILL.md): Available only in this specific project Plugin Skills (<plugin>/skills/<skill-name>/SKILL.md): Available where the plugin is enabled Enterprise Skills: Managed by your organization, available to all users

When Skills share the same name, personal Skills override project Skills. Plugin Skills use a plugin-name:skill-name namespace, so they can't conflict with other Skills.

Here's the basic structure of SKILL.md:

The YAML frontmatter (stuff between the --- lines) contains metadata. The name identifies your Skill and becomes the slash command for manual invocation. The description helps Claude decide when to use this Skill — a clear description increases the likelihood Claude will automatically load it when appropriate.

Below the frontmatter, write your instructions in plain Markdown. Be clear and specific — Claude follows what you write.

Claude discovers Skills at the start of each chat session. If you create or modify a Skill during a conversation, start a new session to make those changes available.

Skills activate in three ways:

Automatic: Claude reads your request and available Skill descriptions. If Claude thinks a Skill is relevant, it loads that Skill automatically. The description helps Claude make this decision, but it's not guaranteed — think of it as a strong suggestion rather than a rule. A clear, specific description increases the chances Claude will choose your Skill.

Manual with name: Mention the Skill name explicitly in your request: "Use the explain-code skill to analyze this function" or "Analyze this with explain-code". This guarantees Claude loads that specific Skill.

Manual with slash command: Type /skill-name to invoke the Skill directly: /explain-code src/auth.js. This is the most explicit invocation method.

This distinction is important: automatic activation works most of the time for informational Skills, but for Skills that do dangerous things (like committing code or deploying apps), you want manual invocation to ensure they only run when you explicitly trigger them. We'll cover how to enforce manual invocation and add other safety controls in the next unit.

Let's create a Skill that makes Claude explain code with analogies and diagrams. We'll create this as a personal Skill so it's available across all your projects.

Create ~/.claude/skills/explain-code/SKILL.md:

The description "Use when explaining how code works" helps Claude recognize when this Skill is relevant. Ask "explain this function" and Claude will likely load this Skill automatically. You can also invoke it directly with /explain-code or by mentioning "explain-code" in your request.

The instructions provide a consistent format. When Claude uses this Skill, it will follow this structure — analogy first, then diagram, then steps, then gotchas.

Here's what you might get for a for loop:

Before we go further, it's important to understand what Skills actually are. Skills are instructions that guide Claude's behavior. They're flexible — Claude interprets them and adapts them to the situation. Think of them like cooking techniques: "sauté the vegetables until golden" leaves room for judgment about timing and heat.

This is different from Tool Calls, which are deterministic operations like Read (view a file), Write (create a file), Edit (modify a file), or Bash (run a command). These tools do exactly what they say, every time, with no interpretation.

When you create a Skill that says "Review code for security issues," Claude uses its judgment to determine what constitutes a security issue. When Claude uses the Read tool to view a file, there's no judgment — it reads the file.

Skills can use tools as part of their work. A code review Skill might read files, search for patterns, and run tests. But the Skill itself is the guidance about how to perform the review, not the mechanical operations.

This distinction matters because Skills are about extending Claude's expertise and behavior, while tools are about what Claude can physically do. You might create a Skill that teaches Claude how to write commit messages in a specific format, but the actual git operations happen through the Bash tool.

Skills work best as a collection of focused capabilities rather than one massive "do everything" Skill. Create multiple Skills, each handling one job well.

Let's build a second Skill that formats code consistently. Create ~/.claude/skills/format-code/SKILL.md:

This Skill handles one specific task: making code more readable without changing its behavior. When you ask Claude to "clean up this messy function," Claude might automatically load this Skill based on the description match. Or invoke it directly with /format-code.

Now you have two Skills in your toolkit. The explain-code Skill helps you understand code, while format-code helps you improve it. Each Skill does one thing well.

As you work with Claude, you'll discover opportunities to create more Skills. Perhaps you want a Skill for writing unit tests, or one for drafting PR descriptions, or one for explaining error messages. Each time you find yourself giving Claude the same instructions, consider turning those instructions into a Skill.

Once you've built several useful Skills, package them into a Plugin to share with others. A Plugin is just a collection of Skills with some metadata.

Create this structure:

The plugin.json file describes your package:

Now anyone can install your Plugin and get all your Skills at once. No need to recreate each Skill individually. It's the difference between sharing individual photos versus sharing an entire album.

We'll cover Plugins in more detail in an upcoming unit, including how to publish and install them.

Skills work alongside Claude's base capabilities. When you create a Skill, you're not removing Claude's general knowledge — you're adding specialized expertise on top of it.

Without the explain-code Skill, Claude can still explain code. The Skill just ensures explanations follow a consistent format with analogies, diagrams, and step-by-step breakdowns. It's like the difference between someone who can cook and a chef trained in a specific cuisine — both can prepare food, but the chef has specialized techniques.

This means you don't need Skills for everything. Create Skills for:

• Tasks you do repeatedly with specific requirements
• Workflows that need consistent structure
• Expertise you want Claude to always apply in certain contexts

Don't create Skills for one-off questions or tasks that don't benefit from structured guidance.

You learned how to create Skills in .claude/skills/ with YAML frontmatter containing name and description, plus Markdown instructions for Claude to follow. Skills activate automatically when Claude determines they match your request, or manually when you explicitly mention the Skill name. Skills are behavioral instructions that guide Claude's expertise, different from deterministic Tool Calls like reading or running commands. Build focused Skills that each handle one job well rather than creating monolithic "do everything" Skills. Package Skills into Plugins with plugin.json for easy distribution.

In the practice exercises, you'll create your own Skills and experiment with automatic vs manual invocation.

Next lesson covers advanced frontmatter configuration — adding safety controls like requiring manual invocation for dangerous operations and restricting which tools a Skill can access.