Claude Skills Tutorial 2026: Build Custom AI Workflows in 10 Minutes

What Are Claude Skills?

Claude Skills are organized folders of instructions, scripts, and resources that Claude loads dynamically to perform specialized tasks. Released by Anthropic in October 2025 and published as an open standard in December 2025, Skills represent a paradigm shift in how we customize AI assistants.

Think of Skills as "task packs" that teach Claude specific workflows. Instead of repeating instructions every time you start a conversation, you define them once in a Skill, and Claude automatically applies them when relevant.

Key Characteristics of Claude Skills

• Modular Design: Each Skill is self-contained in its own directory with a SKILL.md file as the entry point
• Dynamic Discovery: Claude automatically scans available Skills and determines when to use them based on your current task
• Progressive Disclosure: Only metadata loads initially; full instructions load on-demand, saving tokens
• Cross-Platform: Skills work across Claude.ai, Claude Code, API, and third-party platforms
• No-Code Friendly: Basic Skills require only markdown - no programming necessary

What Can Skills Do?

Skills enable Claude to:

• Follow organization-specific workflows and coding standards
• Work with specialized file formats (Excel, PowerPoint, Word, PDF)
• Execute deterministic operations via bundled scripts
• Apply brand guidelines and communication standards
• Automate complex multi-step DevOps processes
• Integrate with external systems via MCP connections

Availability and Pricing

Claude Skills are available on paid plans:

How Claude Skills Work

The magic of Claude Skills lies in their progressive disclosure architecture. This approach is like a well-organized manual that starts with a table of contents, then loads specific chapters only when needed.

The Four Loading Stages

1. Metadata Loading (~100 tokens): At startup, Claude scans all available Skills and loads only the name and description from each SKILL.md frontmatter
2. Skill Selection: Based on your request, Claude semantically matches the task to relevant Skill descriptions
3. Full Instructions (<5,000 tokens): When Claude determines a Skill applies, it reads the full SKILL.md body
4. Resource Loading: Additional files (reference.md, examples.md, scripts/) load only as needed

Why This Matters: Token Efficiency

Traditional system prompts consume tokens constantly, regardless of whether they are relevant to your current task. Skills are different:

• Metadata scanning uses approximately 100 tokens regardless of how many Skills are available
• Full SKILL.md content loads only when triggered
• Scripts execute without loading into context (only output consumes tokens)
• Reference files load on-demand, not upfront

Skill Discovery Flow

Here is how Claude decides when to use a Skill:

User Request
    |
    v
Metadata Scan (all Skills, ~100 tokens)
    |
    v
Semantic Matching (description vs. request)
    |
    v
Skill Triggered? ----No----> Normal Claude behavior
    |
   Yes
    v
Load SKILL.md body (<5K tokens)
    |
    v
Read additional files as needed
    |
    v
Execute bundled scripts if applicable
    |
    v
Complete task using Skill guidance

Where Skills Are Stored

Claude discovers Skills from multiple locations:

Creating Your First Skill (Step-by-Step)

Let us create a simple Skill that helps generate professional greetings. This will demonstrate the core concepts without any coding.

Step 1: Create the Skill Directory

mkdir -p .claude/skills/greeting-generator

Step 2: Create SKILL.md with Required Frontmatter

Create a file named SKILL.md in your new directory:

---
name: greeting-generator
description: Generates personalized greetings for emails, messages, and announcements. Use when the user asks for help writing greetings, welcomes, or introductions.
---

# Greeting Generator

## Overview
This skill helps create warm, professional greetings for various contexts.

## Instructions
1. Identify the context (email, message, announcement)
2. Determine the tone (formal, casual, celebratory)
3. Include personalization when names are provided
4. Keep greetings concise but warm

## Examples

### Formal Email Greeting
"Dear [Name], I hope this message finds you well."

### Casual Team Message
"Hey team! Quick update for everyone..."

### Celebratory Announcement
"We're thrilled to announce..."

## Guidelines
- Match tone to context
- Use recipient's name when available
- Avoid overly generic phrases
- Consider cultural appropriateness

Step 3: Test the Skill

Simply ask Claude something that matches the Skill description:

"Help me write a greeting for a project kickoff email to the engineering team"

Claude will automatically discover and apply the greeting-generator Skill.

Understanding the SKILL.md Structure

Every SKILL.md must begin with YAML frontmatter containing two required fields:

Expanded Skill Structure

For more complex Skills, you can add additional files:

.claude/skills/
└── pdf-processing/
    ├── SKILL.md              # Main instructions
    ├── FORMS.md              # Form-filling guide
    ├── reference.md          # API reference
    ├── examples.md           # Usage examples
    └── scripts/
        ├── analyze_form.py   # Utility script
        ├── fill_form.py      # Form filling script
        └── validate.py       # Validation script

DevOps Skill Examples

DevOps is one of the strongest use cases for Claude Skills. Here are three practical examples you can adapt for your team.

1. Terraform IaC Skill

This Skill ensures consistent Terraform configurations across your team:

---
name: terraform-iac
description: Creates and validates Terraform configurations following company standards. Use when writing or reviewing .tf files, planning infrastructure, or troubleshooting Terraform state.
---

# Terraform IaC Standards

## Module Structure
```
modules/
├── vpc/
│   ├── main.tf
│   ├── variables.tf
│   ├── outputs.tf
│   └── versions.tf
├── eks/
└── rds/
```

## Naming Conventions
- Resources: `{env}-{project}-{resource-type}`
- Variables: `snake_case`
- Outputs: `{resource}_id`, `{resource}_arn`

## Required Tags
All resources must include:
```hcl
tags = {
  Environment = var.environment
  Project     = var.project_name
  ManagedBy   = "terraform"
  Owner       = var.team_email
}
```

## Security Requirements
- No hardcoded secrets (use AWS Secrets Manager)
- Enable encryption at rest for all storage
- Restrict security groups to minimum required ports
- Use private subnets for databases

## Validation
Run before apply:
```bash
terraform fmt -check
terraform validate
tfsec .
```

2. Kubernetes Troubleshooting Skill

---
name: k8s-troubleshooter
description: Diagnoses Kubernetes issues and provides remediation steps. Use when pods are failing, services are unreachable, or cluster health is degraded.
---

# Kubernetes Troubleshooting Guide

## Diagnostic Workflow

### Step 1: Identify the Problem
```bash
kubectl get pods -A | grep -v Running
kubectl get events --sort-by='.lastTimestamp' | tail -20
```

### Step 2: Pod Issues

**CrashLoopBackOff:**
1. Check logs: `kubectl logs <pod> --previous`
2. Check resources: `kubectl describe pod <pod>`
3. Common causes: OOMKilled, missing config, failed probes

**ImagePullBackOff:**
1. Verify image exists: `docker pull <image>`
2. Check registry credentials
3. Verify network access to registry

**Pending:**
1. Check node resources: `kubectl describe nodes`
2. Check PVC bindings
3. Check nodeSelector/affinity rules

## Quick Reference

| Symptom | First Check | Common Fix |
|---------|-------------|------------|
| Pod not starting | `describe pod` | Fix image/config |
| Service no endpoints | Pod labels | Match selector |
| OOMKilled | Resource limits | Increase memory |

3. CI/CD Pipeline Skill

---
name: ci-cd-optimizer
description: Creates and optimizes CI/CD pipelines for GitHub Actions, GitLab CI, and Jenkins. Use when setting up new pipelines, improving build times, or implementing security scanning.
---

# CI/CD Pipeline Standards

## GitHub Actions Template
```yaml
name: CI Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm test
      - run: npm run build

  security:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Trivy
        uses: aquasecurity/trivy-action@master
```

## Optimization Rules
1. Cache dependencies (npm, pip, Maven)
2. Use matrix builds for multiple versions
3. Fail fast on first error
4. Parallelize independent jobs
5. Use artifacts for cross-job data

Finance Skill Examples

Financial services can benefit enormously from Skills. NBIM demonstrated this by saving 213,000 hours annually with Claude Skills.

1. Financial Analysis Skill

---
name: financial-analysis
description: Analyzes financial statements, calculates key metrics, and generates investment reports. Use when reviewing earnings, building DCF models, or comparing company financials.
---

# Financial Analysis Procedures

## Key Metrics to Calculate

### Profitability
- Gross Margin = (Revenue - COGS) / Revenue
- Operating Margin = Operating Income / Revenue
- Net Margin = Net Income / Revenue
- ROE = Net Income / Shareholders' Equity
- ROIC = NOPAT / Invested Capital

### Valuation
- P/E Ratio = Price / EPS
- EV/EBITDA = Enterprise Value / EBITDA
- P/B Ratio = Price / Book Value
- DCF = Sum of (FCF / (1 + WACC)^n)

### Liquidity
- Current Ratio = Current Assets / Current Liabilities
- Quick Ratio = (Cash + Receivables) / Current Liabilities
- Debt/Equity = Total Debt / Shareholders' Equity

## Report Structure
1. Executive Summary (3-5 key findings)
2. Financial Performance Analysis
3. Peer Comparison
4. Valuation Assessment
5. Risk Factors
6. Investment Recommendation

## Output Format
Always include:
- Data table with key metrics
- YoY and QoQ comparisons
- Industry benchmarks
- Visual charts when appropriate

2. Risk Assessment Skill

---
name: risk-assessment
description: Evaluates investment risks, performs Monte Carlo simulations, and generates risk reports. Use when analyzing portfolio risk, stress testing, or regulatory compliance.
---

# Risk Assessment Framework

## Risk Categories

### Market Risk
- Value at Risk (VaR) - 95% and 99% confidence
- Expected Shortfall (CVaR)
- Beta coefficient
- Correlation analysis

### Credit Risk
- Default probability
- Loss given default
- Exposure at default
- Credit rating implications

## Stress Testing Scenarios
- 2008 Financial Crisis replay
- Interest rate +300bps shock
- Market drawdown -30%
- Currency devaluation -20%

## Compliance Checks
- Basel III requirements
- Dodd-Frank reporting
- CCAR stress tests
- Internal risk limits

E-Commerce Skill Examples

E-commerce businesses can use Skills to standardize inventory management, customer service, and order processing.

1. Inventory Management Skill

---
name: inventory-manager
description: Optimizes inventory levels, predicts demand, and manages stock across warehouses. Use when analyzing inventory, planning reorders, or optimizing supply chain.
---

# Inventory Management System

## Key Metrics

### Stock Levels
- Days of Supply = Current Inventory / Daily Sales Rate
- Stock Turn = COGS / Average Inventory
- Fill Rate = Orders Fulfilled / Total Orders

### Reorder Calculations
- Reorder Point = (Lead Time * Daily Sales) + Safety Stock
- Safety Stock = Z-score * Std Dev of Demand * Sqrt(Lead Time)
- EOQ = Sqrt((2 * Demand * Order Cost) / Holding Cost)

## Alert Thresholds
| Status | Days of Supply |
|--------|----------------|
| Critical | < 7 days |
| Low | 7-14 days |
| Normal | 14-45 days |
| Excess | > 45 days |

## Actions

### Low Stock
1. Check supplier lead times
2. Evaluate expedited shipping cost
3. Identify substitute products
4. Update availability on storefront

### Excess Stock
1. Analyze slow-moving items
2. Propose markdown strategy
3. Consider warehouse transfer
4. Evaluate liquidation options

2. Customer Service Skill

---
name: customer-service
description: Handles customer inquiries, processes returns, and escalates issues appropriately. Use when responding to customer tickets, chat, or reviewing service quality.
---

# Customer Service Guidelines

## Response Templates

### Order Status
"Hi [Name], your order #[ORDER] is currently [STATUS].
Expected delivery: [DATE].
Track it here: [LINK]"

### Return Request
"I understand you'd like to return [ITEM].
Our 30-day return policy covers this purchase.
Here's your return label: [LINK]
Refund processed within 5-7 business days of receipt."

### Issue Escalation
"I apologize for this experience.
I'm escalating to our specialist team.
Expect a response within 24 hours.
Reference: [TICKET]"

## Escalation Triggers
- Customer mentions legal action
- Third return request in 30 days
- Order value > $500 with issue
- Shipping delay > 14 days
- Social media mention

## Metrics to Track
- First Response Time (target: < 4 hours)
- Resolution Time (target: < 24 hours)
- CSAT Score (target: > 4.5/5)
- First Contact Resolution (target: > 70%)

Skills vs MCP: Understanding the Difference

A common question is how Skills differ from MCP (Model Context Protocol). The answer is simple: MCP connects Claude TO data; Skills teach Claude WHAT TO DO with that data.

How They Work Together

Skills and MCP are complementary. A single Skill can orchestrate multiple MCP servers, while a single MCP server can support dozens of different Skills.

Example:

• MCP Server: Connects Claude to your Notion workspace
• Skill: "Meeting Prep" - teaches Claude which Notion pages to pull, how to format prep documents, and team standards for meeting notes

Best Practices for Creating Skills

Structure and Design

1. Keep SKILL.md Under 500 Lines: Push detailed docs to separate referenced files. Use progressive disclosure for complex content.
2. Write Trigger-Rich Descriptions: Claude uses semantic matching on descriptions. Include key terms users might say. Example: "Processes Excel files, spreadsheets, .xlsx files, tabular data"
3. Use Third Person in Descriptions: Good: "Processes Excel files and generates reports." Bad: "I can help you process Excel files."
4. Consistent Naming: Use lowercase letters, numbers, and hyphens only. Examples: "terraform-validator", "k8s-troubleshooter"

Content Guidelines

5. Avoid Time-Sensitive Information: Bad: "If before August 2025, use old API." Good: Use "Legacy patterns" section with clear conditions.
6. Use Consistent Terminology: Choose one term and use it throughout. Document your terminology choices.
7. Provide Examples: Include input/output pairs showing expected behavior.
8. Reference Files One Level Deep: Bad: SKILL.md references advanced.md references details.md. Good: SKILL.md references all files directly.

Testing

9. Test with Multiple Models:
   • Haiku: Provide more guidance
   • Sonnet: Balance clarity and efficiency
   • Opus: Avoid over-explaining
10. Build Evaluations First: Create test scenarios before writing extensive docs. Measure baseline, then iterate.
11. Gather Team Feedback: Does Skill activate when expected? Are instructions clear? What is missing?

Conclusion and Next Steps

Claude Skills represent a significant evolution in AI customization. By providing a structured, token-efficient way to teach Claude specialized tasks, Anthropic has created a system that is:

• Accessible: No coding required for basic Skills
• Scalable: Progressive disclosure handles unlimited content
• Portable: Open standard works across platforms (Microsoft, OpenAI, GitHub adopted it)
• Practical: Real enterprise ROI demonstrated (213,000 hours saved at NBIM)

Your Next Steps

1. Start Simple: Create a basic Skill with just SKILL.md before adding scripts
2. Focus on Description: The description is critical for discovery - invest time here
3. Test Iteratively: Use one Claude conversation to write Skills, another to test them
4. Leverage Community: Check anthropics/skills and awesome-claude-skills before building from scratch
5. Document Your Patterns: Skills are knowledge capture - document what works for your team

Additional Resources

• Gheware Skills Examples - Production-ready DevOps, Finance, and E-Commerce skills from this tutorial
• Claude Skills Documentation - Official documentation
• Anthropic Skills Repository - Official examples (37.4K stars)
• Skills Best Practices - Authoring guide from Anthropic
• Skills Announcement - Original feature launch blog post