Use, don't build: when to use a ready-made Claude skill and when to create your own

Module: 6. Skills: reusable expertise | Time: about 25 min theory + 20 min practice

The gist

The lessons on skills (what skills are, building a skill from scratch, skill architecture, evals) taught you how to create skills. This lesson is about the opposite: when not to create one.

Anthropic and the community have already released dozens of ready-made skills that cover most typical tasks: code review, drafting an email, sprint planning, an SEO audit, a brand review, financial analysis. Many of them are free and available through the Claude Code plugin marketplace (the /plugin command). But every installed plugin has a cost: its description goes into the context of every session, and the plugin runs with your permissions (more on that below).

The main principle of this lesson is use, don't build. If the task is a typical one, open a ready-made skill and get going. If you write a skill from scratch for something Anthropic has already done, you lose hours and get a worse result than the tested solution.

🎨 Picture this: skills are recipes. Anthropic has handed you a box of ready ones: pilaf, borscht, pizza, tiramisu. You can open the page and cook in 30 minutes. Or you can invent your own pizza recipe from scratch: 5 hours of experiments, and the cheese burns. Most tasks are a pizza that has already been invented. Don't reinvent it. Only invent what isn't in the book, say, Ecuadorian-style roast cuy with a check of the supplier's RUC (Ecuador's tax ID).

🎯 Decision tree: use vs. build

The main question isn't "should I write my own?" It's "why do I think there's nothing ready-made?"

Is the task typical (code review, draft email, sprint plan, SEO audit, etc.)?
  → Yes → Is there an Anthropic skill for it?
    → Yes → ✅ Use the existing one → done
    → No → Is there a community skill?
      → Yes → Security audit ([plugin security](101-plugin-security.html)) → if OK → use it
      → No → Build your own
  → No → Is the task domain-specific?
    → Yes → Build your own
    → No → You may be overestimating how unique it is. Try a generic skill.

The default is use. Build only when you've clearly hit a wall.

🎨 Picture this: a Toyota Hilux vs. a Lamborghini. A ready-made skill is the Hilux: it runs for 30 years, it's reliable, it won't impress anyone. Your own skill from scratch is the Lamborghini: a beautiful idea, but three months later you give up on it because the upkeep costs more than the car.

Key concepts

• Plugin Marketplace: the plugin catalog in Claude Code. Open /plugin and look at the Discover tab; to install by name, use /plugin install <plugin>@<marketplace>
• Anthropic Official Skills: skills and plugins released by Anthropic across many categories; tested and maintained
• Community Skills: open-source skills from developers (on GitHub); they need a security audit before you install them
• Skill Audit: checking a community skill for safety (what it reads, what it writes, which commands it runs)
• Use Don't Build: the principle of looking for something ready-made first and building only if you don't find it
• NIH (Not Invented Here): the anti-pattern of "I'll write it from scratch because I like it that way"
• Skill as condensed expertise: every Anthropic skill is packaged best practices from a specialist team

Theory

The Anthropic skills catalog: examples of ready-made skills

Below are examples by category: this is what ready-made skills in the Claude Code plugin marketplace look like. The list changes from month to month, so check the current set through /plugin (the Discover tab). The plugins themselves are free, but model usage counts against your plan: current prices and versions: What's current.

Engineering

Design

Marketing

Data

Sales

sales:call-prep, sales:pipeline-review, sales:competitive-intelligence, sales:account-research, sales:daily-briefing, sales:draft-outreach, sales:forecast, sales:call-summary

Product Management

product-management:sprint-planning, :product-brainstorming, :write-spec, :roadmap-update, :metrics-review, :competitive-brief, :stakeholder-update, :synthesize-research

Operations

operations:runbook, :process-optimization, :status-report, :vendor-review, :change-request, :capacity-plan, :risk-assessment, :process-doc

Customer Support

customer-support:customer-escalation, :kb-article, :customer-research, :draft-response, :ticket-triage

HR

human-resources:onboarding, :org-planning, :performance-review, :policy-lookup, :people-report, :interview-prep, :comp-analysis, :recruiting-pipeline

Finance

finance:journal-entry, :reconciliation, :variance-analysis, :audit-support, :sox-testing, :financial-statements, :close-management, :journal-entry-prep

Anthropic Specialty

anthropic-skills:canvas-design, :skill-creator, :internal-comms, :algorithmic-art, :pdf, :xlsx, :docx, :pptx, :theme-factory, :brand-guidelines, :mcp-builder, :web-artifacts-builder, :slack-gif-creator, :consolidate-memory, :schedule and others.

Superpowers: a meta-methodology

Search/SEO

searchfit-seo:seo-audit, :on-page-seo, :keyword-clustering, :content-brief, :content-strategy, :technical-seo, :schema-markup, :ai-visibility, :broken-links, :internal-linking and others.

Figma

figma:figma-design-to-code, :figma-generate-design, :figma-generate-diagram, :figma-code-connect, :figma-generate-library and others.

Productivity

productivity:memory-management, :task-management, :start, :update

Where to get skills (sources)

3 cases when you really do need to build

Case 1: A domain-specific workflow

You're a real estate agent in Ecuador. Nobody has written a skill that:

• Validates a supplier's RUC (tax ID) through the local SRI (tax agency) API
• Runs a cadastral search in the Cuenca property registry
• Applies local pricing rules (legacy sucre amounts, USD conversion)

That's a narrow domain. Nobody will do it for you. Build.

Case 2: A custom brand voice

The standard marketing:draft-content doesn't know your brand. If you have a BRAND-VOICE.md written (see AI copywriting), wrap it in a skill. That way your style gets applied automatically every time instead of generic marketing copy.

Case 3: Proprietary processes

Your company's internal onboarding process. Your team's specific workflow. Not for publishing, just for use inside the organization. Nobody else is going to do that.

Anti-patterns (what NOT to do)

❌ NIH (Not Invented Here): "I'll write it from scratch because I like it that way." You lose hours and get a version that works worse.

❌ Wrapping something existing for no reason: making a code-review-pro that just wraps engineering:code-review without adding any value is a waste of time.

❌ Reinventing at scale: community skills for typical tasks are usually more polished than your first version. Use them first, study how they're built, then make your own if you need to.

❌ Premature optimization: "I'll have special requirements in 6 months." But in 6 months the requirements will have changed. Don't build now for future requirements that don't exist yet.

❌ A skill for a one-time task: a skill is a reusable pattern. If you're doing something once, that's just a prompt, not a skill.

A skills audit for your setup (practical)

Regular hygiene, once a quarter:

1. Open /plugin and go to the Installed tab (or look at the file ~/.claude/plugins/installed_plugins.json)
2. The list of all plugins and skills you've installed
3. For each one: did you use it in the last 30 days? (the Installed tab has a "Not used recently" group)
4. If not: is there a good reason to keep it "for later," or can you remove it?
5. Goal: 80% of what's installed is in active use

Hidden costs of installed skills:

Good community sources (checked in October 2026)

Before installing a community skill, always audit it using the Plugin security lesson.

Skills as a way to learn

A big bonus that many people miss: a skill is the condensed expertise of the Anthropic team in that area.

• Want to learn design? Study design:design-critique: it packages design review practices
• Want to learn marketing? marketing:campaign-plan holds the built-in knowledge of marketers
• Want to learn debugging? superpowers:systematic-debugging is a step-by-step debugging method
• Want finance? finance:variance-analysis is the methodology of FP&A analysts

When you use a skill, you don't just get output: you learn the right approach. Every prompt inside is an expert's ready-made workflow on the topic.

🎨 Picture this: a skill lets you stand on the shoulders of giants. The skill's authors spent time getting the approach to code review right. You get the result of their work in the few seconds it takes to install.

Where you are now: a rating by level

The main beginner mistake is trying to write your own skills right away. First learn to use the ready-made ones. You'll understand the patterns. Then make your own where you see a real gap.

Practice

Step 1: See what you already have installed

# What Claude Code has downloaded and installed
ls ~/.claude/plugins/

# The list of installed plugins as JSON
cat ~/.claude/plugins/installed_plugins.json | head -50

# Or directly through Claude Code
# In a new session: /plugin (the Installed tab)

Step 2: Find a skill for a typical task

Say your task is to write a social media post about a new agent framework.

Before writing from scratch, search:

# In Claude Code
/plugin

# Or search by category
# marketing:* for content
# searchfit-seo:* for SEO

marketing:draft-content fits. Install it and use it instead of an ad-hoc prompt.

Step 3: Install an Anthropic skill

# In Claude Code: open /plugin, the Discover tab, pick a plugin
# Or with a command, by plugin name and marketplace
/plugin install <plugin>@<marketplace>

Once installed, a skill from the plugin is called as /<plugin>:<skill>, and Claude also picks it up automatically based on its description.

Step 4: Audit a community skill before installing it

Say you found an interesting skill, karpathy-style-debugger, on GitHub.

Before installing:

# Clone it somewhere OTHER than your plugins folder
git clone https://github.com/forrestchang/andrej-karpathy-skills /tmp/audit-skill

# Check it
cd /tmp/audit-skill
ls -la

# 1. Read the frontmatter of every .md file
# 2. Which Bash commands does it run?
grep -r "Bash" .

# 3. Which files does it read / write?
grep -r "Read\|Write\|Edit" .

# 4. What's in the install script, if there is one?
cat install.sh 2>/dev/null

# 5. How active is the repository?
# When was the last commit? How many stars? Any open issues?

See the Plugin security lesson for a detailed checklist.

If everything is clean, put the skill in ~/.claude/skills/ (available in all projects) or in the project's .claude/skills/.

Step 5: Quarterly hygiene

# Once a quarter: audit what you actually use
cat ~/.claude/plugins/installed_plugins.json | jq '.plugins | keys'

# For each one, think back: did you use it in the last 30 days?
# If not, remove it or mark it "waiting for a use case"

# Remove one you don't use
/plugin uninstall <name>

# Log what you removed and why
echo "$(date): uninstalled <name> — not used for 30+ days" >> ~/.claude/skills-audit.log

Step 6: Build only when you clearly need to: an example

Say you've confirmed that there's no ready-made skill for cuenca-real-estate-deal-validator. Then:

# Use skill-creator (a meta-skill) to create a new one
# In Claude Code:
/plugin
# Find anthropic-skills:skill-creator
# Enable it
# Describe the task, and it will generate the right structure

Don't write skill .md files from scratch by hand. Use skill-creator to get the correct format right away, with frontmatter, examples and edge cases.

Checklist (✅)

• I checked the Anthropic Plugin Marketplace for my task before "writing from scratch"
• I know how to find community skills (the awesome list on GitHub)
• I removed skills I haven't used (in the last 30 days)
• My community skills passed an audit (the checklist from the Plugin security lesson)
• I use skill-creator when I really do need to build (I don't write .md files by hand)
• 80% of installed skills are in active use, the rest are up for review

Tools and resources

• Anthropic Plugin Marketplace: official plugins
• Awesome Claude Code: a collection of community resources
• Claude Code Plugin Docs: installation, configuration
• Skill Format Spec: the format for your own skills
• SuperClaude Framework: an advanced community framework
• Karpathy Skills: coding principles as skills
• Claude Marketplace: a plugin catalog on the website
• skill-creator: a meta-skill for creating your own (look for it in /plugin)
• Prices and versions: What's current

Key takeaways

Use, don't build: principle #1. Before you write your own skill, check that there isn't a ready-made one. Anthropic and the community have released dozens of ready-made skills. Most typical tasks are already covered. You can save hours every week.

3 cases when building is justified: a domain-specific workflow (a real estate agent in Ecuador, not "yet another code reviewer"), a custom brand voice (your style in marketing), proprietary processes (internal onboarding). In every other case, use what exists.

Skills are condensed expertise. Every ready-made skill is packaged best practices from a specialist team. When you use them, you don't just get output: you learn the right approach. Every skill is a textbook on its topic in a form you can actually use.

Quarterly hygiene. Every three months, audit your installed plugins (/plugin). Remove the ones you haven't used in 30 days. Goal: 80% of what's installed is in active use. Otherwise your context grows for no benefit.

What's next

→ Hooks: automatic rules in Claude Code: the next step after skills, rules that fire on their own without you calling them