What Are Claude Skills? The Complete Guide for 2026

TL;DR

Claude Skills are reusable instruction files — written in plain Markdown — that modify how Claude Code behaves during a session. Think of them as browser extensions for AI: install one, and Claude gains new expertise, workflows, or tool integrations without any code changes. With over 60,000 community-published skills available in 2026, they have become the primary way developers customize Claude Code for specific tasks, from frontend design to database architecture to security auditing. Skills are free, composable, and take seconds to install. Rating: Essential for any Claude Code user — 4.7/5.

Table of Contents

1. What Are Claude Skills?
2. Key Features of Claude Skills
3. How to Install Claude Skills (Step-by-Step)
4. 10 Best Claude Skills to Start With
5. How to Build Your Own Claude Skill
6. Pros and Cons
7. Claude Skills vs Alternatives
8. Final Verdict
9. Frequently Asked Questions

What Are Claude Skills?

Claude Skills are Markdown files — typically named SKILL.md — that inject persistent instructions, context, and behavioral rules into Claude Code sessions. When a skill is installed, Claude reads its contents at the start of every conversation and follows the directives inside. The result: a version of Claude that is specialized for a particular domain, workflow, or toolchain.

The simplest analogy is browser extensions for AI. Just as a Chrome extension adds password management or ad blocking without rewriting the browser itself, a Claude Skill adds new capabilities — code review patterns, design system knowledge, deployment workflows — without modifying Claude's underlying model. The skill file sits in the project or user configuration directory, and Claude picks it up automatically.

The SKILL.md Format

Every Claude Skill is a plain Markdown document. There is no proprietary format, no YAML front matter requirement, no compilation step. A skill file contains three types of content:

• Behavioral instructions — Rules that tell Claude how to act. ("Always use TypeScript strict mode." "Never suggest inline styles." "Follow the Airbnb style guide.")
• Domain knowledge — Context that Claude should treat as ground truth. (API reference snippets, architecture decisions, brand voice guidelines, internal naming conventions.)
• Workflow definitions — Step-by-step procedures Claude should follow for specific tasks. ("When asked to create a component, first check the design system tokens, then scaffold with the template, then write tests.")

A minimal skill file might be 20 lines. A comprehensive one — like Anthropic's official Frontend Design skill — can exceed 500 lines with detailed heuristics, examples, and edge-case handling.

How Skills Modify Claude's Behavior

When Claude Code launches, it reads configuration files in a specific order of precedence:

1. User-level settings (~/.claude/) — Global preferences that apply everywhere.
2. Project-level CLAUDE.md — Instructions scoped to a specific codebase.
3. Installed skills — Additional instruction sets loaded from the skills directory.

Skills merge into Claude's system context alongside the project's own CLAUDE.md. They do not override project-level instructions — they extend them. This means a developer can have a project-specific CLAUDE.md that defines their codebase conventions, plus a "Security Auditor" skill that adds penetration-testing awareness, plus a "Technical Writer" skill that improves documentation output — all active simultaneously.

The practical effect is significant. Without skills, every Claude Code user starts from the same baseline and must manually re-explain their preferences in every conversation. With skills, those preferences persist, compound, and can be shared across teams and projects. It is the difference between hiring a generalist and hiring a specialist who already knows the playbook.

Key Features of Claude Skills

Natural Language Configuration

Skills require zero programming knowledge to create or modify. Because they are written in plain Markdown, anyone who can write a clear sentence can write a skill. There are no APIs to learn, no SDKs to install, no build tools to configure.

This matters because it democratizes AI customization. A product manager can write a skill that ensures Claude follows the team's PRD template. A copywriter can create one that enforces brand voice guidelines. A QA engineer can build one that makes Claude always suggest edge-case tests. The barrier to entry is literacy, not code.

Editing a skill is equally simple — open the Markdown file, change the text, save. The updated behavior takes effect on the next Claude session. No redeployment, no version bumps, no dependency management.

Context Injection

Skills solve one of the most persistent friction points in AI-assisted development: context loss between sessions. Without skills, developers frequently spend the first several exchanges of a conversation re-explaining their tech stack, coding conventions, architecture patterns, and project constraints.

A well-written skill pre-loads all of this information. Claude enters the conversation already knowing that the project uses Next.js 15 with the App Router, that the team prefers Zod for validation, that the database is Supabase with Row Level Security enabled, and that all components must be accessible to WCAG 2.2 AA standards. None of this needs to be restated.

Context injection is persistent — it applies to every session in the project. It is also selective — different skills inject different contexts, and only the installed skills contribute their knowledge.

Tool and Workflow Automation

Skills can define multi-step workflows that Claude executes in sequence. Rather than giving Claude ad-hoc instructions each time, a skill encodes the entire procedure.

For example, a deployment skill might specify: "When the user says 'deploy to staging,' run the test suite first. If tests pass, build the Docker image, push to the container registry, update the Kubernetes manifest, apply it to the staging namespace, and run smoke tests. Report the results with the deployment URL." Claude follows this procedure consistently, every time, without the developer needing to remember or retype the steps.

Workflow skills are particularly valuable for onboarding. A new team member installs the project's skills and immediately has access to the same automated procedures that senior engineers use. The knowledge gap shrinks from weeks to minutes.

Cross-Project Portability

Skills are files. Files can be copied, version-controlled, and shared. A developer who creates a skill for one project can drop the same file into another project and get the same behavior. Organizations maintain shared skill repositories that standardize how Claude operates across all their codebases.

This portability extends across machines and team members. A skill stored in a Git repository can be cloned by anyone with access. There are no license keys, no account-specific bindings, no per-seat limitations. The skill works wherever Claude Code runs.

Many teams store their skills in a dedicated skills/ directory within their monorepo, versioned alongside the code. When the team updates its conventions, the skill file gets a pull request just like any other code change.

Community Marketplace

The Claude Skills ecosystem has grown rapidly since Anthropic opened the skill installation API. As of March 2026, over 60,000 community-published skills are available across platforms like GitHub, the skiln.co directory, and dedicated marketplaces.

The range is enormous. There are skills for specific frameworks (React, Vue, Svelte, Rails, Django), specific tasks (code review, refactoring, testing, documentation), specific industries (fintech compliance, healthcare HIPAA, e-commerce), and specific tools (Docker, Terraform, Kubernetes, AWS CDK).

Quality varies — which is precisely why curated directories like skiln.co exist. Rather than sifting through thousands of unvetted skill files, developers can browse categorized, reviewed, and rated skills with installation instructions and compatibility information.

One-Click Installation

Installing a skill from a directory or GitHub repository takes a single command:

claude skill install <github-url>

There is no dependency resolution, no package conflicts, no build step. The command downloads the SKILL.md file (and any associated assets) to the appropriate configuration directory, and it is immediately active.

From the skiln.co directory, the process is even simpler. Each skill listing includes a copy-paste install command and, for supported integrations, a one-click install button that triggers the CLI command automatically.

Uninstalling is equally straightforward: claude skill remove . No cleanup scripts, no orphaned configurations.

Composability

Skills are designed to work together. Unlike monolithic configuration systems where adding one preset disables another, Claude Skills stack additively. A developer can run a "TypeScript Strict" skill alongside a "React Best Practices" skill alongside a "Security Hardening" skill, and all three contribute their instructions to the session.

Claude resolves potential conflicts using a priority system. Project-level CLAUDE.md instructions take highest precedence, followed by user-level skills, followed by project-level skills. Within the same level, later-loaded skills can override earlier ones. In practice, conflicts are rare because most skills address orthogonal concerns.

Composability enables a "skill stack" approach — developers maintain a curated set of 3-8 skills that, combined, produce a highly customized Claude experience tailored to their exact workflow.

Custom Slash Commands Integration

Skills can define custom slash commands that trigger specific behaviors. A skill might register /deploy, /review, /test, or /docs as shortcuts that invoke complex multi-step procedures with a single command.

Slash commands turn skills from passive context providers into active workflow tools. Instead of writing "please review this code with attention to security vulnerabilities, performance issues, and adherence to our style guide," the developer types /review and Claude executes the full procedure defined in the skill.

Commands can accept arguments, too. /deploy staging might route to the staging workflow while /deploy production triggers the production pipeline with additional safety checks. The skill file defines the command behavior, and Claude interprets it at runtime.

How to Install Claude Skills (Step-by-Step)

There are three primary methods for adding skills to a Claude Code environment. Each serves a different use case.

Method 1: Install from GitHub

The most common method. Most community skills are hosted as public GitHub repositories.

Step 1: Find a skill. Browse the skiln.co skill directory or search GitHub for repositories tagged claude-skill.

Step 2: Install with the CLI.

claude skill install github.com/anthropics/claude-skill-frontend-design

This clones the repository and places the SKILL.md file in your project's .claude/skills/ directory.

Step 3: Verify installation.

claude skill list

The output shows all installed skills with their source and status.

Step 4: Test the skill. Start a new Claude Code session and ask Claude about the skill's domain. If the skill is a frontend design skill, ask Claude to scaffold a component. The response should reflect the skill's instructions — design system tokens, accessibility patterns, or whatever the skill specifies.

Step 5: Configure (optional). Some skills include configurable parameters at the top of their SKILL.md. Open the file in .claude/skills/ and adjust values as needed.

Method 2: One-Click from skiln.co

The skiln.co directory provides a streamlined installation experience.

Step 1: Navigate to any skill listing on skiln.co/browse.

Step 2: Click the Install button on the skill page. This copies the install command to the clipboard.

Step 3: Paste and run the command in your terminal.

claude skill install skiln.co/s/frontend-design

Step 4: The skill is now active. No further configuration is needed unless the skill's documentation specifies optional settings.

Step 5: To browse installed skills and manage them, run:

claude skill list --verbose

Method 3: Write Your Own SKILL.md

For project-specific customization, writing a skill from scratch is often the best approach.

Step 1: Create a file named SKILL.md in your project's .claude/skills/ directory (or any subdirectory within .claude/).

mkdir -p .claude/skills && touch .claude/skills/SKILL.md

Step 2: Open the file and write your instructions in plain Markdown:

# My Project Skill

## Code Style
- Use TypeScript strict mode for all files
- Prefer named exports over default exports
- Use Zod for all runtime validation
- Follow the project's existing naming conventions

## Component Patterns
- All React components must be functional components
- Use the `cn()` utility from `lib/utils` for conditional classes
- Every component needs a corresponding test file

## Testing
- Write tests using Vitest
- Minimum 80% branch coverage for new code
- Always test error states and loading states

Step 3: Save the file. The skill is immediately active for all Claude Code sessions in that project.

Step 4: Iterate. Run a Claude session, observe the behavior, and refine the instructions. The most effective skills are developed through 3-5 rounds of testing and revision.

Step 5: Share the skill. If it is useful beyond the current project, publish it to GitHub and submit it to skiln.co for inclusion in the directory.

10 Best Claude Skills to Start With

These ten skills represent the most impactful starting points for developers new to the Claude Skills ecosystem. Each has been tested, reviewed, and rated by the skiln.co editorial team.

1. Superpowers (by Obra)

The most popular Claude Skill in the ecosystem — and for good reason. Superpowers enhances Claude's core coding capabilities with advanced problem-solving heuristics, better error handling, and more thorough code analysis. It is the "essential extension" that virtually every Claude Code user installs first.

claude skill install github.com/obraai/claude-skill-superpowers

2. Frontend Design (by Anthropic)

Anthropic's official skill for frontend development. It teaches Claude to produce production-quality UI code with proper semantic HTML, accessible patterns, responsive design, and modern CSS techniques. Especially effective when paired with a component library skill.

claude skill install github.com/anthropics/claude-skill-frontend-design

3. Playwright Pro

Turns Claude into an expert at writing end-to-end tests with Playwright. The skill includes patterns for handling async operations, managing test fixtures, writing resilient selectors, and debugging flaky tests. A significant time saver for teams adopting E2E testing.

claude skill install github.com/nicobailey/claude-skill-playwright-pro

4. shadcn/ui Skill

Purpose-built for projects using the shadcn/ui component library. Claude learns the component API, theming system, and composition patterns specific to shadcn/ui. It generates components that match the library's conventions instead of generic React code.

claude skill install github.com/saliftankoano/shadcn-ui-skill

5. PR Review Expert

Transforms Claude into a rigorous code reviewer. The skill defines review criteria for security, performance, maintainability, and correctness. It catches issues that standard linters miss — logic errors, race conditions, missing error boundaries, and architectural anti-patterns.

claude skill install github.com/anthropics/claude-skill-pr-review

6. RAG Architect

For teams building retrieval-augmented generation systems. This skill gives Claude deep knowledge of embedding strategies, chunking algorithms, vector database optimization, re-ranking techniques, and evaluation metrics. It produces RAG pipelines that perform measurably better than naive implementations.

claude skill install github.com/jmanhype/RAG-Architect-Claude-Skill

7. Database Designer

Covers schema design, query optimization, migration strategies, and indexing decisions across PostgreSQL, MySQL, and SQLite. The skill enforces normalization best practices while knowing when to denormalize for performance. Particularly effective for Supabase and PlanetScale projects.

claude skill install github.com/anthropics/claude-skill-database-designer

8. Trail of Bits Security Audit

Developed by Trail of Bits, one of the most respected security firms in the industry. This skill trains Claude to identify vulnerabilities using the same mental models that professional auditors use. It covers OWASP Top 10, supply chain risks, authentication flaws, and cryptographic pitfalls.

claude skill install github.com/trailofbits/claude-skill-security-audit

9. Expo Skills

Essential for React Native developers working with Expo. The skill covers Expo Router, EAS Build, native module configuration, and platform-specific patterns for iOS and Android. It eliminates the trial-and-error that typically accompanies cross-platform mobile development.

claude skill install github.com/expo/claude-skill-expo

10. MCP Builder

A meta-skill for building MCP servers. It teaches Claude the Model Context Protocol specification, server architecture patterns, tool and resource definition, and testing strategies. Developers use it to create custom MCP servers that extend Claude's capabilities in new directions.

claude skill install github.com/nicobailey/claude-skill-mcp-builder

Browse the full directory of curated skills at skiln.co/skills.

How to Build Your Own Claude Skill

Building a custom skill is straightforward. The process has three phases: define, test, and refine.

Define the scope. A good skill does one thing well. Instead of creating a "Full Stack Development" skill that tries to cover everything, create focused skills: "Next.js App Router Patterns," "Supabase RLS Policies," "Vitest Testing Conventions." Narrow scope produces sharper behavior.

Write clear instructions. Use imperative language. Say "always use named exports" rather than "named exports are preferred." Be specific — "use the cn() utility from @/lib/utils for conditional classnames" is more useful than "use utility functions for styling." Include examples where behavior might be ambiguous.

Structure with Markdown headings. Claude parses the heading hierarchy to understand instruction categories. Use H2 for major sections (Code Style, Testing, Architecture) and H3 for specific rules within each section.

Test iteratively. Install the skill, run 5-10 representative prompts, and note where Claude deviates from expected behavior. Strengthen those instructions with more explicit language or examples. Most skills reach optimal performance after 3-5 revision cycles.

Publish and share. Push the skill to a public GitHub repository with a descriptive README. Tag it with claude-skill for discoverability. Submit it to the skiln.co directory for wider distribution and community review.

For a complete walkthrough with templates and advanced techniques, see the full tutorial: How to Build a Claude Skill from Scratch.

Pros and Cons

Pros

• Zero-code customization. Anyone who can write Markdown can create or modify a skill. No programming, APIs, or build tools required.
• Instant installation. A single CLI command installs a skill in seconds. No dependency conflicts, no environment setup, no version compatibility issues.
• Composable by design. Multiple skills stack together without conflict. Developers build personalized "skill stacks" that combine domain expertise across several areas.
• Persistent across sessions. Once installed, a skill applies to every conversation. No more re-explaining project conventions at the start of each session.
• Massive community ecosystem. Over 60,000 published skills cover virtually every framework, language, and workflow. The odds of finding an existing skill for a specific need are high.
• Version-controllable. Skills are text files that live in Git repositories. Teams review, version, and track changes to their skills the same way they track code changes.

Cons

• Quality inconsistency. The open ecosystem means anyone can publish a skill. Many community skills are poorly written, outdated, or untested. Curation is essential.
• No runtime sandboxing. Skills inject instructions directly into Claude's context. A malicious or poorly written skill could instruct Claude to perform undesirable actions. Users must trust the source.
• Context window consumption. Every installed skill consumes tokens from Claude's context window. Installing too many large skills simultaneously can reduce the available space for actual conversation and code.
• Limited discoverability. Despite 60,000+ published skills, finding the right one for a specific need still requires searching multiple sources — GitHub, directories, forums. The ecosystem lacks a unified search experience.
• No dependency management. Skills do not declare dependencies on other skills. If Skill A assumes Skill B is also installed, there is no mechanism to enforce or automate that relationship.

Claude Skills vs Alternatives

How do Claude Skills compare to similar customization systems in competing AI coding tools?

Key takeaways from this comparison:

Claude Skills vs Custom GPTs. Custom GPTs have a larger marketplace (3M+), but each GPT is a siloed experience — users cannot combine multiple GPTs in one session. Skills are composable, portable, and version-controllable. For developers working in code, Skills are the stronger option. For consumer-facing chatbot use cases, GPTs have broader reach.

Claude Skills vs Copilot Extensions. Copilot Extensions are more powerful in one sense — they can execute arbitrary code and interact with external APIs. But they require TypeScript or Python development, approval processes, and are locked to the VS Code ecosystem. Skills offer faster iteration and broader accessibility at the cost of runtime capabilities.

Claude Skills vs Cursor Rules. The closest competitor. Both use plain text files for instruction injection. Cursor Rules are simpler (a single .cursorrules file per project) but lack composability, community distribution, slash commands, and the ability to stack multiple configurations. Skills are more flexible; Cursor Rules are more minimalist.

For a deeper dive into this comparison, see Claude Skills vs MCP Servers vs Plugins: What's the Difference? on the skiln.co blog.

Final Verdict

Claude Skills have become the standard mechanism for customizing AI-assisted development workflows in 2026. They solve a real problem — the repetitive friction of re-explaining context, preferences, and procedures to an AI that starts each session from scratch — with an elegant solution: plain text files that anyone can write, share, and compose.

The ecosystem's strengths are clear. Zero-code creation, instant installation, composability, and a community of 60,000+ published skills make it easy to get started and deep enough to sustain long-term use. The best skills — Superpowers, Frontend Design, the Trail of Bits security skill — genuinely transform how developers interact with Claude.

The weaknesses are equally real. Quality control is inconsistent, context window costs add up, and discoverability remains fragmented. These are ecosystem maturity problems, not architectural ones, and they are improving as curated directories like skiln.co and quality rating systems mature.

For any developer using Claude Code in 2026, skills are not optional — they are foundational. Start with 2-3 high-quality skills from the skiln.co directory, learn how they work, and then write a custom one for the project. The investment is measured in minutes. The return is measured in hours saved per week.

Overall rating: 4.7/5 — Essential for every Claude Code user. The ecosystem is not perfect, but the value proposition is overwhelming.

Frequently Asked Questions

Are Claude Skills free to use?

Yes. Claude Skills are free Markdown files. There is no cost to install, create, or distribute them. The only requirement is an active Claude Code subscription (Claude Pro, Team, or Enterprise), which provides access to the Claude Code CLI where skills are installed and executed.

How many skills can I install at the same time?

There is no hard limit on the number of installed skills. However, each skill consumes tokens from Claude's context window. In practice, most developers run 3-8 active skills without issues. If combined skill content exceeds approximately 15,000 tokens, consider disabling less critical skills or consolidating overlapping instructions into a single file.

Do skills work with Claude Desktop or just Claude Code?

Skills are a Claude Code feature. They are loaded by the CLI and injected into the session context. Claude Desktop (the chat application) does not support SKILL.md files. However, Claude Desktop supports MCP servers, which provide complementary capabilities. For a comparison, see skiln.co/blog/claude-skills-vs-mcp-servers-vs-plugins.

Can a skill access my files or execute code on its own?

No. Skills are passive instruction sets — they tell Claude how to behave but cannot independently access the filesystem, run commands, or make network requests. Claude Code itself has those capabilities (with user permission), and a skill can instruct Claude to use them in certain ways, but the skill file alone has no execution power.

How do I know if a skill is safe to install?

Review the skill's source code before installing. Since skills are plain Markdown, the entire content is human-readable. Look for instructions that seem overly broad ("ignore all previous instructions"), request sensitive data exfiltration, or instruct Claude to bypass permission prompts. Curated directories like skiln.co review submitted skills for safety and quality before listing them.

What is the difference between a Claude Skill and an MCP server?

A Claude Skill provides instructions and knowledge — it tells Claude what to do and how to think. An MCP (Model Context Protocol) server provides tools and data access — it gives Claude the ability to interact with external systems like databases, APIs, and file services. Skills customize behavior; MCP servers extend capabilities. They are complementary, not competing. Most advanced setups use both. Learn more at skiln.co/mcps.

Can I use skills created by other people in my commercial projects?

Check the license of each skill. Most community skills are published under MIT or Apache 2.0 licenses, which permit commercial use. Some skills have more restrictive licenses or no license at all (which technically means all rights reserved). The skiln.co directory displays license information on each skill's listing page.

How do I update an installed skill?

Run the install command again with the same source URL. The CLI overwrites the existing skill file with the latest version. There is no automatic update mechanism — skills update only when explicitly reinstalled. To check if updates are available, visit the skill's repository or directory listing.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "What Are Claude Skills? The Complete Guide for 2026",
  "description": "Learn what Claude Skills are, how to install them, and the best skills to start with. The definitive 2026 guide to extending Claude Code with reusable skill files.",
  "datePublished": "2026-03-21",
  "dateModified": "2026-03-21",
  "author": {
    "@type": "Organization",
    "name": "Skiln",
    "url": "https://skiln.co"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Skiln",
    "url": "https://skiln.co",
    "logo": {
      "@type": "ImageObject",
      "url": "https://skiln.co/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://skiln.co/blog/what-are-claude-skills"
  },
  "wordCount": 4200,
  "keywords": ["claude skills", "what are claude skills", "claude code skills", "SKILL.md", "claude skills guide", "best claude skills", "how to install claude skills"]
}

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Are Claude Skills free to use?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Claude Skills are free Markdown files. There is no cost to install, create, or distribute them. The only requirement is an active Claude Code subscription (Claude Pro, Team, or Enterprise), which provides access to the Claude Code CLI where skills are installed and executed."
      }
    },
    {
      "@type": "Question",
      "name": "How many skills can I install at the same time?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "There is no hard limit on the number of installed skills. However, each skill consumes tokens from Claude's context window. In practice, most developers run 3-8 active skills without issues. If combined skill content exceeds approximately 15,000 tokens, consider disabling less critical skills or consolidating overlapping instructions."
      }
    },
    {
      "@type": "Question",
      "name": "Do skills work with Claude Desktop or just Claude Code?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Skills are a Claude Code feature. They are loaded by the CLI and injected into the session context. Claude Desktop (the chat application) does not support SKILL.md files. However, Claude Desktop supports MCP servers, which provide complementary capabilities."
      }
    },
    {
      "@type": "Question",
      "name": "Can a skill access my files or execute code on its own?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Skills are passive instruction sets — they tell Claude how to behave but cannot independently access the filesystem, run commands, or make network requests. Claude Code itself has those capabilities (with user permission), and a skill can instruct Claude to use them, but the skill file alone has no execution power."
      }
    },
    {
      "@type": "Question",
      "name": "How do I know if a skill is safe to install?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Review the skill's source code before installing. Since skills are plain Markdown, the entire content is human-readable. Look for instructions that seem overly broad, request sensitive data exfiltration, or instruct Claude to bypass permission prompts. Curated directories like skiln.co review submitted skills for safety and quality before listing them."
      }
    },
    {
      "@type": "Question",
      "name": "What is the difference between a Claude Skill and an MCP server?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A Claude Skill provides instructions and knowledge — it tells Claude what to do and how to think. An MCP server provides tools and data access — it gives Claude the ability to interact with external systems like databases, APIs, and file services. Skills customize behavior; MCP servers extend capabilities. They are complementary, not competing."
      }
    },
    {
      "@type": "Question",
      "name": "Can I use skills created by other people in my commercial projects?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Check the license of each skill. Most community skills are published under MIT or Apache 2.0 licenses, which permit commercial use. Some skills have more restrictive licenses. The skiln.co directory displays license information on each skill's listing page."
      }
    },
    {
      "@type": "Question",
      "name": "How do I update an installed skill?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Run the install command again with the same source URL. The CLI overwrites the existing skill file with the latest version. There is no automatic update mechanism — skills update only when explicitly reinstalled."
      }
    }
  ]
}