Welcome to Unit 3 of Skills — Extending Claude's Capabilities! You have made excellent progress; we have explored the Skills system fundamentals, understood when to create Skills versus using CLAUDE.md, and built two practical Skills from scratch. Now we are ready to tackle more sophisticated challenges.

In this lesson, we will explore advanced skill patterns and best practices. We will examine how advanced Skills coordinate multiple tools, learn to debug Skill selection, and discover when not to create a Skill. We will also establish design principles for maintainable, effective Skills.

By the end of this lesson, you will understand Skill architecture, common pitfalls to avoid, and the patterns that separate good Skills from great ones. Let's elevate our Skills to the next level!

What makes Skills advanced?

Advanced Skills differ from basic ones through sophisticated coordination. While basic Skills might read a file and write output, advanced Skills orchestrate multiple operations that build on each other: analyzing existing code, generating new files based on findings, and verifying results through execution.

The Multi-Tool Coordination Pattern:

Most advanced Skills follow a three-phase workflow:

1. Analysis Phase — Use Read to understand context (existing code, project standards, requirements)
2. Generation Phase — Use Write or Edit to create new content based on analysis
3. Verification Phase — Use Bash to test that generated content works correctly

Each phase depends on the previous one. The analysis informs what to generate, and verification confirms the generation succeeded. Let's see this pattern in action by building a real advanced Skill.

Let's build an api-tester skill that demonstrates these advanced patterns. We will walk through creating it, testing it, and observing how it coordinates multiple tools automatically.

Step 1: Ask Claude to create it

We start with a specific request that describes what we want:

Claude responds by creating the Skill:

Notice the frontmatter specifies four tools (Read, Write, Edit, Bash) and the description includes keywords like "comprehensive," "edge cases," and "error handling." The process section outlines the three-phase workflow we discussed.

Step 2: Test the skill

After restarting Claude Code to load the new Skill, we make a request:

How to See Which Skill Was Selected:

Claude explicitly indicates when it selects a Skill:

The bracket notation [Skill selected: skill-name] appears whenever a Skill activates. You may also see Skill(skill-name) notation. No indicator means Claude used general knowledge without any Skill. This helps verify your Skill descriptions are working correctly.

Common Selection Problems and Fixes:

When Claude selects the wrong Skill or fails to select the right one, several issues might be at play:

Problem: Descriptions too similar

Fix: Use specific keywords unique to each Skill's domain.

Problem: Vague requests

Fix: Make requests specific to match Skill descriptions and "When to Use" triggers.

When NOT to Create Skills:

Skills add maintenance overhead and selection complexity. Avoid creating them for:

One-off tasks

Single operations with no pattern don't need Skills.

Simple operations

Claude already handles basic file operations.

General knowledge

Explanations don't require specialized workflows.

Project-wide rules

Use CLAUDE.md for rules that apply everywhere, not Skills for enforcement.

When TO Create Skills:

Create Skills when they solve genuine, recurring problems:

Regular tasks

Repeated workflows benefit from automation.

Domain expertise

Specialized knowledge about structures justifies a Skill.

Multi-step procedures

Complex workflows benefit from guidance.

Write Specific, Keyword-Rich Descriptions:

Include concrete actions and domain terms users naturally mention. Keywords like "extract," "tables," "PDF," and "invoices" help Claude match requests.

Include a "When to Use" Section:

List specific scenarios and phrases to improve selection accuracy.

Apply Least Privilege with Tools:

Only grant tools the Skill actually needs. This makes capabilities clear and prevents unintended actions.

Keep Skills Concise: Aim for 200-500 lines total. Longer Skills become hard to maintain and understand. If your Skill grows beyond this, consider splitting it into multiple focused Skills.

Test Multiple Phrasings: Try different ways developers might request the task:

• "Generate tests for this API"
• "Add test coverage to the endpoint"
• "Test the /users route"

All should trigger the same Skill reliably. If they don't, add those phrases to "When to Use."

We have explored advanced skill patterns and best practices. Advanced Skills coordinate multiple tools through structured workflows: analysis, generation, and verification. They solve recurring problems with consistent patterns and require careful design through specific descriptions, focused purposes, and thorough testing.

Equally important is knowing when not to create a Skill. Simple operations, one-off tasks, and general knowledge don't warrant the overhead. Use CLAUDE.md for project-wide rules and reserve Skills for specialized, repeating workflows.

You now have the toolkit for creating powerful Skills that extend Claude's capabilities meaningfully. Looking ahead: The api-tester skill you built demonstrates multi-tool coordination, and in Unit 4 you will discover how Claude orchestrates multi-skill workflows using these same principles of clear descriptions and focused purposes. In the upcoming practice exercises, you will apply these principles to build advanced Skills, debug selection issues, and make thoughtful decisions about when Skills add value. Let's put these techniques into action!