# Anthropic Skills — User Guide

## 1. Quick Start

Anthropic Skills is a curated collection of reusable skill packages for Claude Code. Each skill extends Claude's capabilities in a specific domain — from generating Office documents and PDFs to building MCP servers, creating animated GIFs, and testing web applications. Skills are prompt-and-script bundles that Claude Code loads on demand, giving it domain expertise and helper tooling it would not otherwise have.

**Key features:**

- 16 production-ready skills spanning document creation, design, development, and testing
- Claude API reference skill with complete examples in Python, TypeScript, Go, Java, PHP, Ruby, and C#
- Office document skills (DOCX, PPTX, XLSX) with full OOXML validation
- MCP server builder for creating Model Context Protocol servers
- Skill creator meta-skill for building and evaluating new skills
- Web application testing with Playwright automation
- Animated GIF creation optimized for Slack emoji and messages

**Prerequisites:** Claude Code installed and configured with an Anthropic API key.

**Install the skill pack:**

```bash
claude skills install anthropics/skills
```

> [!TIP]
> After installation, invoke any skill by name in your Claude Code session — for example, type `/pdf` to activate the PDF skill, or `/claude-api` for API reference material.

**Try it — create a PDF:**

```text
/pdf
Create a one-page summary of my project README
```

```text
[Claude reads your README, generates a styled PDF, and saves it to the output directory]
```

**What to try next:** See the skill catalog in Core Usage for the full list, or jump to Common Tasks for real-world recipes.

## 2. Installation

### System Requirements

| Requirement | Minimum |
|---|---|
| Claude Code | Latest stable release |
| Node.js | 18+ (for web artifact skills) |
| Python | 3.10+ (for script-based skills) |
| Anthropic API key | Set as `ANTHROPIC_API_KEY` env var |

### Installing Skills

```bash
claude skills install anthropics/skills
```

```text
Installed 16 skills from anthropics/skills
```

> [!IMPORTANT]
> On Windows, ensure your Node.js installation path does not contain spaces. A known issue (#954) causes skill updates to fail when the path includes spaces — install Node.js to a path like `C:\nodejs` instead.

### Verifying Installation

```bash
claude skills list
```

```text
algorithmic-art      Generate algorithmic art with JavaScript
brand-guidelines     Evaluate and apply brand guidelines
canvas-design        Create canvas-based designs
claude-api           Claude API reference and examples
doc-coauthoring      Collaborative document editing
docx                 Create and edit Word documents
frontend-design      Design frontend interfaces
internal-comms       Write internal communications
mcp-builder          Build MCP servers
pdf                  Create and manipulate PDFs
pptx                 Create PowerPoint presentations
skill-creator        Create and evaluate new skills
slack-gif-creator    Create animated GIFs for Slack
theme-factory        Generate design themes
web-artifacts-builder Build web artifacts with bundling
webapp-testing       Test web applications with Playwright
xlsx                 Create Excel spreadsheets
```

### Skill-Specific Dependencies

Some skills require additional Python packages. Install them when prompted, or proactively:

=== "Slack GIF Creator"
    ```bash
    pip install pillow>=10.0.0 imageio>=2.31.0 imageio-ffmpeg>=0.4.9 numpy>=1.24.0
    ```

=== "MCP Builder"
    ```bash
    pip install anthropic>=0.39.0 mcp>=1.1.0
    ```

=== "Office Documents (DOCX/PPTX/XLSX)"
    ```bash
    pip install lxml defusedxml
    ```

=== "Web App Testing"
    ```bash
    pip install playwright
    playwright install chromium
    ```

### Install Troubleshooting

### Error: `skills update fails on Windows when Node.js path contains spaces`

**Cause:** The skill update mechanism cannot resolve paths with spaces on Windows.

**Solution:**
1. Reinstall Node.js to a path without spaces (e.g., `C:\nodejs`)
2. Update your `PATH` environment variable
3. Retry the skill installation

**Prevention:** Always install Node.js to a space-free path on Windows.

### Error: `ANTHROPIC_API_KEY not set`

**Cause:** The Claude API skill and MCP builder require a valid API key.

**Solution:**
```bash
export ANTHROPIC_API_KEY="your-api-key"
```

**Prevention:** Add the export to your shell profile (`~/.bashrc`, `~/.zshrc`).

## 3. Configuration

Skills are configured through their `SKILL.md` files — markdown documents that define the skill's identity, instructions, and available tools. Users do not typically edit these files directly; they are read by Claude Code when a skill is invoked.

Each skill directory follows a standard layout:

```text
skills/{skill-name}/
├── SKILL.md          # Skill definition (name, description, instructions)
├── LICENSE.txt       # License (MIT for most skills)
├── scripts/          # Helper scripts Claude can execute
├── reference/        # Reference documentation
└── examples/         # Usage examples
```

> [!NOTE]
> For the complete skill specification and how to create custom skills, see the Admin Guide.

For skill-specific configuration (API keys, model selection, tool preferences), follow the instructions that Claude provides when you invoke each skill. The Claude API skill, for example, uses the `ANTHROPIC_API_KEY` environment variable and lets you specify model names inline.

## 4. Core Usage

Skills are organized into four categories: **Document Creation**, **Design & Media**, **Development**, and **Testing & Quality**.

### Document Creation Skills

#### PDF — Create and Manipulate PDFs

Invoke with `/pdf`. Creates PDF documents from scratch, fills forms, extracts content, and validates bounding boxes. Includes helper scripts for form field extraction and annotation-based form filling.

```text
/pdf
Generate a project status report as a branded PDF with our logo
```

The PDF skill provides these helper scripts:

| Script | Purpose |
|---|---|
| `check_bounding_boxes.py` | Validate element positioning |
| `check_fillable_fields.py` | Inspect form field properties |
| `convert_pdf_to_images.py` | Render pages as images for verification |
| `create_validation_image.py` | Generate visual validation overlays |
| `extract_form_field_info.py` | Extract form field metadata |
| `extract_form_structure.py` | Map form structure and hierarchy |
| `fill_fillable_fields.py` | Fill form fields programmatically |
| `fill_pdf_form_with_annotations.py` | Overlay annotations on forms |

#### DOCX — Create and Edit Word Documents

Invoke with `/docx`. Creates Word documents with full OOXML compliance, including tracked changes, comments, and document validation against ISO/IEC 29500-4 schemas.

```text
/docx
Create a meeting minutes template with tracked changes support
```

> [!TIP]
> The DOCX skill includes XML schema validation that catches structural issues before they cause "corrupt file" errors in Word. Let Claude validate your documents after creation.

#### PPTX — Create PowerPoint Presentations

Invoke with `/pptx`. Creates slide decks with support for adding slides, generating thumbnails, and validating OOXML structure. Includes a PptxGenJS integration guide for JavaScript-based generation.

```text
/pptx
Build a 10-slide investor pitch deck from my business plan
```

#### XLSX — Create Excel Spreadsheets

Invoke with `/xlsx`. Creates Excel workbooks with formula recalculation support and full OOXML validation.

```text
/xlsx
Create a budget tracking spreadsheet with formulas for monthly totals
```

#### Doc Co-authoring

Invoke with `/doc-coauthoring`. Enables collaborative document editing workflows where Claude works alongside you on a document iteratively.

### Design & Media Skills

#### Canvas Design

Invoke with `/canvas-design`. Creates canvas-based visual designs using a curated font library with 30+ open-source typefaces (Arsenal SC, Bricolage Grotesque, Crimson Pro, DM Mono, Geist Mono, IBM Plex, Instrument Sans, JetBrains Mono, Lora, Work Sans, and others).

```text
/canvas-design
Design a social media banner for our product launch
```

#### Frontend Design

Invoke with `/frontend-design`. Designs frontend user interfaces with modern web standards, producing HTML/CSS/JavaScript implementations.

```text
/frontend-design
Design a dashboard layout for our analytics application
```

#### Algorithmic Art

Invoke with `/algorithmic-art`. Generates algorithmic art using JavaScript, with a generator template and HTML viewer for real-time rendering.

```text
/algorithmic-art
Create a generative art piece using Perlin noise and particle systems
```

#### Theme Factory

Invoke with `/theme-factory`. Generates comprehensive design themes with color palettes, typography, and component styles. Ships with 10 pre-built themes:

| Theme | Style |
|---|---|
| Arctic Frost | Cool blues and whites |
| Botanical Garden | Natural greens |
| Desert Rose | Warm earth tones |
| Forest Canopy | Deep greens and browns |
| Golden Hour | Warm sunset tones |
| Midnight Galaxy | Dark purples and blues |
| Modern Minimalist | Clean neutrals |
| Ocean Depths | Deep sea blues |
| Sunset Boulevard | Vibrant oranges and pinks |
| Tech Innovation | Modern tech aesthetic |

#### Slack GIF Creator

Invoke with `/slack-gif-creator`. Creates animated GIFs optimized for Slack emoji (128x128) and message attachments. Includes a full animation framework with easing functions, frame composition, and GIF optimization.

```text
/slack-gif-creator
Create a bouncing logo animation for our team's Slack workspace
```

> [!WARNING]
> Slack emoji GIFs must be 128x128 pixels or smaller. The skill automatically resizes and optimizes when you set `optimize_for_emoji=True`, but very complex animations may still exceed Slack's file size limits. Reduce frame count or color palette if the output is too large.

### Development Skills

#### Claude API Reference

Invoke with `/claude-api`. Provides complete, up-to-date API reference and code examples for the Anthropic Claude API across seven languages:

| Language | Package | Managed Agents |
|---|---|---|
| Python | `anthropic` | Full support |
| TypeScript | `@anthropic-ai/sdk` | Full support |
| Go | `anthropic-sdk-go` | Full support |
| Java | `anthropic-java` | Full support |
| PHP | `anthropic-ai/sdk` | Full support |
| Ruby | `anthropic` gem | Full support |
| C# | Anthropic SDK | Basic support |
| cURL | N/A | Examples |

Coverage includes: basic messages, streaming, vision, extended thinking, prompt caching, tool use, error handling, multi-turn conversations, compaction, managed agents (environments, sessions, events, files, vaults, MCP servers, GitHub repository integration), and cost optimization.

> [!NOTE]
> The Claude API skill references `shared/` documents for cross-language concepts like error codes, prompt caching patterns, model migration, and managed agents architecture. These shared references ensure consistency across all language examples.

#### MCP Builder

Invoke with `/mcp-builder`. Scaffolds Model Context Protocol (MCP) servers in Python or Node.js, with best practices documentation and an evaluation framework.

```text
/mcp-builder
Build an MCP server that exposes our internal API endpoints as tools
```

The skill includes reference material for:
- MCP best practices
- Python MCP server patterns
- Node.js MCP server patterns
- Connection testing and evaluation

#### Web Artifacts Builder

Invoke with `/web-artifacts-builder`. Creates standalone web artifacts (HTML/CSS/JS applications) with automatic dependency bundling via shell scripts. Includes shadcn component library integration.

```text
/web-artifacts-builder
Build an interactive data visualization dashboard as a standalone web app
```

#### Skill Creator

Invoke with `/skill-creator`. A meta-skill for creating, evaluating, and packaging new Claude Code skills. Includes an evaluation framework with automated benchmarking and quality grading.

```text
/skill-creator
Create a new skill for generating database migration scripts
```

The skill creator provides:

| Component | Purpose |
|---|---|
| `run_eval.py` | Run evaluation benchmarks |
| `run_loop.py` | Iterative improvement loop |
| `aggregate_benchmark.py` | Aggregate benchmark results |
| `generate_report.py` | Generate evaluation reports |
| `improve_description.py` | Refine skill descriptions |
| `package_skill.py` | Package skill for distribution |
| `quick_validate.py` | Fast validation checks |

> [!WARNING]
> Issue #556 reports that `run_eval.py` may show a 0% trigger rate when skills or commands are not properly registered. Ensure your skill is installed and the trigger patterns in SKILL.md match your test queries.

#### Internal Communications

Invoke with `/internal-comms`. Generates professional internal communications including newsletters, FAQ documents, third-party updates, and general announcements. Includes example templates.

### Testing & Quality Skills

#### Web App Testing

Invoke with `/webapp-testing`. Automates web application testing using Playwright, with examples for element discovery, console log capture, and static HTML automation.

```text
/webapp-testing
Test our login page for accessibility and form validation
```

Example — discovering page elements:

```python
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto('http://localhost:5173')
    page.wait_for_load_state('networkidle')

    buttons = page.locator('button').all()
    print(f"Found {len(buttons)} buttons:")
    for i, button in enumerate(buttons):
        text = button.inner_text() if button.is_visible() else "[hidden]"
        print(f"  [{i}] {text}")

    browser.close()
```

> [!TIP]
> The webapp-testing skill includes a `with_server.py` helper that starts a local development server before running tests. Use it when testing applications that need a running server.

#### Brand Guidelines

Invoke with `/brand-guidelines`. Evaluates content against brand guidelines, checking for consistency in voice, tone, terminology, and visual standards.

## 5. Common Tasks

### Create a Professional PDF Report

**Goal:** Generate a multi-page PDF report from project data.

**Prerequisites:** PDF skill installed, project data available.

**Steps:**
1. Invoke `/pdf` in your Claude Code session
2. Describe the report structure: "Create a quarterly report with executive summary, metrics table, and charts"
3. Point Claude to your data files
4. Review the generated PDF
5. Request revisions as needed

**Verify:** Open the PDF in any viewer; check formatting, page breaks, and embedded data.

**If it fails:** Ensure `reportlab` or `weasyprint` is available in your Python environment.

### Build a Slide Deck from a Document

**Goal:** Convert a written document into a PowerPoint presentation.

**Prerequisites:** PPTX skill installed, source document available.

**Steps:**
1. Invoke `/pptx`
2. Share or point to your source document
3. Specify slide count and style preferences
4. Review generated slides

**Verify:** Open in PowerPoint or LibreOffice Impress.

### Create a Slack Emoji GIF

**Goal:** Create an animated emoji for your Slack workspace.

**Prerequisites:** Slack GIF creator skill installed, `pillow` and `imageio` packages.

**Steps:**
1. Invoke `/slack-gif-creator`
2. Describe the animation (e.g., "spinning logo", "bouncing text", "pulsing heart")
3. Claude generates frames using the easing and composition libraries
4. The GIF is automatically optimized to 128x128 pixels with reduced colors

**Verify:** Upload to Slack via Customize Workspace > Add Emoji.

**If it fails:** Check that `pillow`, `imageio`, and `numpy` are installed. If the file is too large, ask Claude to reduce frames or colors.

### Scaffold an MCP Server

**Goal:** Create a new MCP server exposing custom tools.

**Prerequisites:** MCP builder skill installed, `anthropic>=0.39.0` and `mcp>=1.1.0`.

**Steps:**
1. Invoke `/mcp-builder`
2. Describe the tools you want to expose
3. Choose Python or Node.js
4. Claude scaffolds the server with proper MCP protocol handling
5. Test with the included evaluation framework

**Verify:** Run the server and connect via Claude Code or another MCP client.

### Generate a Design Theme

**Goal:** Create a consistent design theme for your project.

**Prerequisites:** Theme factory skill installed.

**Steps:**
1. Invoke `/theme-factory`
2. Describe your brand or aesthetic preferences
3. Claude generates a complete theme with colors, typography, and component styles
4. Apply the theme to your project

**Verify:** Review the generated theme document against your brand requirements.

### Create a New Custom Skill

**Goal:** Build a reusable Claude Code skill for your team.

**Prerequisites:** Skill creator skill installed.

**Steps:**
1. Invoke `/skill-creator`
2. Describe what the skill should do
3. Claude creates the SKILL.md, scripts, and evaluation tests
4. Run `run_eval.py` to benchmark the skill
5. Package with `package_skill.py`

**Verify:** Install the packaged skill and test it end-to-end.

**If it fails:** Check issue #556 — ensure skill trigger patterns match test queries.

### Test a Web Application

**Goal:** Automate testing of a web application's UI.

**Prerequisites:** Webapp testing skill installed, Playwright and Chromium.

**Steps:**
1. Invoke `/webapp-testing`
2. Provide the URL or point to local HTML files
3. Claude writes and runs Playwright tests
4. Review captured screenshots and console logs

**Verify:** Check the output screenshots in `/mnt/user-data/outputs/` or your configured output directory.

### Use the Claude API in a New Project

**Goal:** Integrate Claude into your application.

**Prerequisites:** Claude API skill installed, `ANTHROPIC_API_KEY` set.

**Steps:**
1. Invoke `/claude-api`
2. Specify your language (Python, TypeScript, Go, Java, PHP, Ruby, C#)
3. Describe your use case (e.g., "streaming chat", "tool use", "managed agents")
4. Claude provides working code examples from the skill's reference material

**Verify:** Run the generated code against the Anthropic API.

## 6. Troubleshooting

### Error: `No frames to save. Add frames with add_frame() first.`

**Cause:** The `GIFBuilder.save()` method was called before adding any frames.

**Solution:**
1. Ensure your animation code calls `add_frame()` or `add_frames()` before `save()`
2. Check that frame generation completed without errors

**Prevention:** Always verify `len(builder.frames) > 0` before calling `save()`.

### Error: Skills update fails on Windows with spaces in path

**Cause:** Node.js installation path contains spaces (e.g., `C:\Program Files\nodejs`).

**Solution:**
1. Reinstall Node.js to `C:\nodejs` or another space-free path
2. Update your `PATH` environment variable
3. Retry the skill update

**Prevention:** Use space-free installation paths on Windows. (GitHub issue #954)

### Error: `run_eval.py` shows 0% trigger rate

**Cause:** Skills or commands are not properly registered in the Claude Code environment.

**Solution:**
1. Verify the skill is installed: `claude skills list`
2. Check that SKILL.md trigger patterns match your test queries
3. Ensure the skill name in SKILL.md matches the directory name

**Prevention:** Test trigger patterns manually before running automated evaluations. (GitHub issue #556)

### DOCX/PPTX/XLSX file appears corrupt in Office

**Cause:** Invalid XML structure, broken relationship references, or duplicate IDs in the OOXML package.

**Solution:**
1. Ask Claude to run the validator: "Validate this document"
2. The validator checks XML well-formedness, namespace declarations, unique IDs, file references, and content types
3. Fix reported issues and regenerate

**Prevention:** Always validate Office documents before distribution. The skills include comprehensive OOXML validators.

> [!CAUTION]
> Broken file references and duplicate relationship IDs in OOXML documents will cause the file to appear corrupt when opened. Always run validation after generating or editing Office documents.

### Playwright tests fail with "browser not found"

**Cause:** Chromium browser is not installed for Playwright.

**Solution:**
```bash
playwright install chromium
```

**Prevention:** Run `playwright install` after installing the `playwright` package.

### GIF file too large for Slack emoji

**Cause:** Too many frames, too many colors, or dimensions larger than 128x128.

**Solution:**
1. Set `optimize_for_emoji=True` when calling `GIFBuilder.save()`
2. Reduce `num_colors` (try 48 or lower)
3. Reduce frame count (12 frames is a good target for emoji)
4. Use `remove_duplicates=True` to eliminate nearly identical frames

**Prevention:** Start with emoji-optimized settings from the beginning.

## 7. FAQ

**Q: How do I see which skills are installed?**

Run `claude skills list` to see all installed skills with their descriptions.

**Q: Can I share skills across my organization?**

Organization-wide skill sharing is a requested feature (GitHub issue #228) but not yet available. Currently, skills must be installed per-user.

**Q: Which skill should I use for creating documents?**

Choose based on the output format: `/pdf` for PDFs, `/docx` for Word documents, `/pptx` for PowerPoint, `/xlsx` for Excel. For collaborative editing workflows, use `/doc-coauthoring`.

**Q: Do I need an API key for all skills?**

Only the `claude-api` and `mcp-builder` skills require an Anthropic API key (`ANTHROPIC_API_KEY`). Other skills use Claude Code's built-in capabilities.

**Q: Can I use the Claude API skill to write code for non-Python languages?**

Yes. The Claude API skill includes complete reference material and examples for Python, TypeScript, Go, Java, PHP, Ruby, C#, and cURL. Specify your preferred language when invoking the skill.

**Q: How do I create my own skill?**

Use the `/skill-creator` meta-skill. It walks you through defining the SKILL.md, writing helper scripts, creating evaluation tests, and packaging the skill for distribution. See the skill template in `template/SKILL.md` for the required format.

**Q: What are managed agents in the Claude API skill?**

Managed agents are persistent, server-side AI agents that run in cloud environments. They support sessions, streaming events, custom tools, file uploads, MCP server integration, vaults for credential management, and GitHub repository mounting. The Claude API skill provides complete code examples for managed agents across all supported languages.

**Q: How do I update skills to the latest version?**

```bash
claude skills update anthropics/skills
```

This pulls the latest versions of all skills from the repository.

**Q: Can I modify a skill's behavior?**

You can fork the skill repository and modify the SKILL.md or scripts to customize behavior. See the Admin Guide for the complete skill specification and development details.

---

_Generated May 2026 from anthropics/skills at d211d43. AI-generated documentation. The library is checked by sampling (three repositories so far); this guide was not individually reviewed. Verify against the project before relying on it. Unofficial; not affiliated with or reviewed by the project._