Claude Agent Skills

https://platform.claude.com/docs/en/agents-and-tools/agent-skills/
Admin
Agent Skills are modular capabilities that extend Claude's functionality by packaging instructions,...
Tokens:26,430
Snippets:250
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Bad example: Magic numbers in configuration

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of configuration values without context or justification.

```python
TIMEOUT = 47  # Why 47?
RETRIES = 5  # Why 5?
```

--------------------------------

### Explicitly document package dependencies

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Avoid assuming packages are installed; provide installation instructions followed by the usage code.

```python
from pypdf import PdfReader
reader = PdfReader("file.pdf")
```

--------------------------------

### PDF Processing Quick Start Instructions

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview

Procedural knowledge contained within SKILL.md. This example demonstrates using the pdfplumber library to extract text from a PDF.

```python
import pdfplumber

with pdfplumber.open("document.pdf") as pdf:
    text = pdf.pages[0].extract_text()
```

--------------------------------

### Time-sensitive content example

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of content that will become outdated, demonstrating what to avoid.

```markdown
If you're doing this before August 2025, use the old API.
After August 2025, use the new API.
```

--------------------------------

### Install Claude API skill as a plugin

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill

Add the skill as a plugin to Claude Code using the marketplace and install commands.

```text
/plugin marketplace add anthropics/skills
/plugin install claude-api@anthropic-agent-skills
```

--------------------------------

### Vague Skill Descriptions to Avoid

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Examples of overly generic descriptions that should be avoided to ensure proper skill selection.

```yaml
description: Helps with documents
```

```yaml
description: Processes data
```

```yaml
description: Does stuff with files
```

--------------------------------

### Commit message format examples

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Input/output pairs demonstrating the expected style and level of detail for commit messages.

```markdown
## Commit message format

Generate commit messages following these examples:

**Example 1:**
Input: Added user authentication with JWT tokens
Output:
```
feat(auth): implement JWT-based authentication

Add login endpoint and token validation middleware
```

**Example 2:**
Input: Fixed bug where dates displayed incorrectly in reports
Output:
```
fix(reports): correct date formatting in timezone conversion

Use UTC timestamps consistently across report generation
```

**Example 3:**
Input: Updated dependencies and refactored error handling
Output:
```
chore: update dependencies and refactor error handling

- Upgrade lodash to 4.17.21
- Standardize error response format across endpoints
```
```

--------------------------------

### BigQuery Data Analysis SKILL.md with Domain References

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of organizing a skill by domain, using links to specific reference files to keep context focused.

```markdown
# BigQuery Data Analysis

## Available datasets

**Finance**: Revenue, ARR, billing → See [reference/finance.md](reference/finance.md)
**Sales**: Opportunities, pipeline, accounts → See [reference/sales.md](reference/sales.md)
**Product**: API usage, features, adoption → See [reference/product.md](reference/product.md)
**Marketing**: Campaigns, attribution, email → See [reference/marketing.md](reference/marketing.md)

## Quick search

Find specific metrics using grep:

```bash
grep -i "revenue" reference/finance.md
grep -i "pipeline" reference/sales.md
grep -i "api usage" reference/product.md
```
```

--------------------------------

### Migrate codebase

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill

Example task for migrating an existing project to claude-opus-5 and re-tuning effort.

```text
/claude-api migrate this codebase to claude-opus-5 and re-tune effort
```

--------------------------------

### Low freedom database migration script

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of low-freedom instructions using a specific command for tasks where consistency and sequence are critical.

```bash
python scripts/migrate.py --verify --backup
```

--------------------------------

### Build a streaming chat UI

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill

Example task for building a streaming chat UI with the Claude API in TypeScript.

```text
Build a streaming chat UI with the Claude API in TypeScript
```

--------------------------------

### Create a spreadsheet using agent skills

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

These examples demonstrate how to request the creation of a quarterly sales tracking spreadsheet by configuring the container skills and tools in the messages API.

```bash
curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 16000,
    "container": {
      "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
    },
    "messages": [
      {"role": "user", "content": "Create a quarterly sales tracking spreadsheet with sample data"}
    ],
    "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
  }'
```

```bash
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 16000
container:
  skills:
    - type: anthropic
      skill_id: xlsx
      version: latest
messages:
  - role: user
    content: Create a quarterly sales tracking spreadsheet with sample data
tools:
  - type: code_execution_20260521
    name: code_execution
YAML
```

```python
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    container={
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
    },
    messages=[
        {
            "role": "user",
            "content": "Create a quarterly sales tracking spreadsheet with sample data",
        }
    ],
    tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
)
```

```typescript
const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 16000,
  container: {
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages: [
    {
      role: "user",
      content: "Create a quarterly sales tracking spreadsheet with sample data"
    }
  ],
  tools: [{ type: "code_execution_20260521", name: "code_execution" }]
});
```

```csharp
var response = await client.Messages.Create(
    new MessageCreateParams
    {
        Model = Model.ClaudeOpus5,
        MaxTokens = 16000,
        Container = new ContainerParams
        {
            Skills =
            [
                new SkillParams
                {
                    Type = SkillParamsType.Anthropic,
                    SkillID = "xlsx",
                    Version = "latest",
                },
            ],
        },
        Messages =
        [
            new MessageParam
            {
                Role = Role.User,
                Content = "Create a quarterly sales tracking spreadsheet with sample data",
            },
        ],
        Tools = [new CodeExecutionTool20260521()],
    }
);
```

```go
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 16000,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "xlsx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a quarterly sales tracking spreadsheet with sample data")),
	},
	Tools: []anthropic.ToolUnionParam{
		{
			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
		},
	},
})
if err != nil {
	panic(err)
}
```

```java
Message response = client.messages().create(
    MessageCreateParams.builder()
        .model(CLAUDE_OPUS_5)
        .maxTokens(16000)
        .container(
            ContainerParams.builder()
                .addSkill(
                    SkillParams.builder()
                        .type(ANTHROPIC)
                        .skillId("xlsx")
                        .version("latest")
                        .build()
                )
                .build()
        )
        .addUserMessage("Create a quarterly sales tracking spreadsheet with sample data")
        .addTool(CodeExecutionTool20260521.builder().build())
        .build()
);
```

```php
$response = $client->messages->create(
    model: 'claude-opus-5',
    maxTokens: 16000,
    container: [
        'skills' => [
            ['type' => 'anthropic', 'skillID' => 'xlsx', 'version' => 'latest'],
        ],
    ],
    messages: [
        [
            'role' => 'user',
            'content' => 'Create a quarterly sales tracking spreadsheet with sample data',
        ],
    ],
    tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
);
```

--------------------------------

### Install Claude API skill via npx

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill

Add the skill to your project using the npx command from the Anthropic skills repository.

```bash
npx skills add https://github.com/anthropics/skills --skill claude-api
```

--------------------------------

### High freedom code review instructions

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of high-freedom instructions using text-based steps for tasks where multiple approaches are valid.

```markdown
## Code review process

1. Analyze the code structure and organization
2. Check for potential bugs or edge cases
3. Suggest improvements for readability and maintainability
4. Verify adherence to project conventions
```

--------------------------------

### Scaffold a Managed Agent

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill

Invoke the managed-agents-onboard subcommand to start the interview process for creating a new Managed Agent.

```text
/claude-api managed-agents-onboard
```

--------------------------------

### Concise PDF text extraction

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A concise example of using pdfplumber for text extraction, assuming Claude already understands PDF basics.

```python
import pdfplumber

with pdfplumber.open("file.pdf") as pdf:
    text = pdf.pages[0].extract_text()
```

--------------------------------

### Create a presentation using Go

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Go SDK to create a message with the PowerPoint skill and print the response details.

```go
// Create a message with the PowerPoint Skill
response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 16000,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "pptx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(
			anthropic.NewTextBlock("Create a presentation about renewable energy with 5 slides"),
		),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{}},
	},
})
if err != nil {
	panic(err)
}

fmt.Printf("stop_reason=%s, blocks=%d\n", response.StopReason, len(response.Content))
```

--------------------------------

### PDF Processing SKILL.md with References

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A sample SKILL.md file demonstrating how to use YAML frontmatter and markdown links to reference external documentation files for advanced features.

```markdown
---
name: pdf-processing
description: Extracts text and tables from PDF files, fills forms, and merges documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
---

# PDF Processing

## Quick start

Extract text with pdfplumber:
```python
import pdfplumber
with pdfplumber.open("file.pdf") as pdf:
    text = pdf.pages[0].extract_text()
```

## Advanced features

**Form filling**: See [FORMS.md](FORMS.md) for complete guide
**API reference**: See [REFERENCE.md](REFERENCE.md) for all methods
**Examples**: See [EXAMPLES.md](EXAMPLES.md) for common patterns
```

--------------------------------

### Create a Word document using CLI

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the CLI to create a message with the docx skill.

```bash
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 16000
container:
  skills:
    - type: anthropic
      skill_id: docx
      version: latest
messages:
  - role: user
    content: Write a 2-page report on the benefits of renewable energy
tools:
  - type: code_execution_20260521
    name: code_execution
YAML
```

--------------------------------

### Bad example: Deferring errors to Claude

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of poor practice where a function fails without handling exceptions, forcing the agent to manage the error.

```python
def process_file(path):
    # Just fail and let Claude figure it out
    return open(path).read()
```

--------------------------------

### Create a Word document in Go

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Go client to create a message with the docx skill.

```go
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 16000,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "docx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Write a 2-page report on the benefits of renewable energy")),
	},
	Tools: []anthropic.ToolUnionParam{
		{
			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
		},
	},
})
if err != nil {
	panic(err)
}
```

--------------------------------

### Document modification workflow

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A conditional workflow pattern guiding decision-making between different task types.

```markdown
## Document modification workflow

1. Determine the modification type:

   **Creating new content?** → Follow "Creation workflow" below
   **Editing existing content?** → Follow "Editing workflow" below

2. Creation workflow:
   - Use docx-js library
   - Build document from scratch
   - Export to .docx format

3. Editing workflow:
   - Unpack existing document
   - Modify XML directly
   - Validate after each change
   - Repack when complete
```

--------------------------------

### Self-documenting configuration constants

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Use comments to explain the reasoning behind configuration values to avoid magic numbers.

```python
# HTTP requests typically complete within 30 seconds
# Longer timeout accounts for slow connections
REQUEST_TIMEOUT = 30

# Three retries balances reliability vs speed
# Most intermittent failures resolve by the second retry
MAX_RETRIES = 3
```

--------------------------------

### Create a presentation using Python

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Python SDK to create a message with the PowerPoint skill and print the response details.

```python
# Create a message with the PowerPoint Skill
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    container={
        "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
    },
    messages=[
        {
            "role": "user",
            "content": "Create a presentation about renewable energy with 5 slides",
        }
    ],
    tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
)

print(f"stop_reason={response.stop_reason}, blocks={len(response.content)}")
```

--------------------------------

### Create a presentation using C#

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the C# SDK to create a message with the PowerPoint skill and output the response status.

```csharp
// Create a message with the PowerPoint Skill
var response = await client.Messages.Create(new MessageCreateParams
{
    Model = Model.ClaudeOpus5,
    MaxTokens = 16000,
    Container = new ContainerParams
    {
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "pptx",
                Version = "latest",
            },
        ],
    },
    Messages =
    [
        new MessageParam
        {
            Role = Role.User,
            Content = "Create a presentation about renewable energy with 5 slides",
        },
    ],
    Tools = [new CodeExecutionTool20260521()],
});

Console.WriteLine($"stop_reason={response.StopReason?.Raw()}, blocks={response.Content.Count}");
```

--------------------------------

### Create a presentation using the CLI

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Anthropic CLI to create a message with the PowerPoint skill configured in the YAML input.

```bash
# Create a message with the PowerPoint Skill
response=$(ant messages create --format json <<'YAML'
model: claude-opus-5
max_tokens: 16000
container:
  skills:
    - type: anthropic
      skill_id: pptx
      version: latest
messages:
  - role: user
    content: Create a presentation about renewable energy with 5 slides
tools:
  - type: code_execution_20260521
    name: code_execution
YAML
)
```

--------------------------------

### PDF Processing Skill Description

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Example of an effective description for a PDF processing skill, specifying both the capability and the trigger context.

```yaml
description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
```

--------------------------------

### Define SKILL.md structure

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview

The required format for a Skill file, including YAML frontmatter for metadata and sections for instructions and examples.

```markdown
---
name: your-skill-name
description: Brief description of what this Skill does and when to use it
---

# Your Skill Name

## Instructions
[Clear, step-by-step guidance for Claude to follow]

## Examples
[Concrete examples of using this Skill]
```

--------------------------------

### Handle errors explicitly in Python

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A good example of a Python function that handles FileNotFoundError and PermissionError internally rather than failing.

```python
def process_file(path):
    """Process a file, creating it if it doesn't exist."""
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError:
        # Create file with default content instead of failing
        print(f"File {path} not found, creating default")
        with open(path, "w") as f:
            f.write("")
        return ""
    except PermissionError:
        # Provide alternative instead of failing
        print(f"Cannot access {path}, using default")
        return ""
```

--------------------------------

### Create a quarterly sales tracking spreadsheet in Ruby

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Ruby client to create a message with the xlsx skill enabled.

```ruby
response = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 16_000,
  container: {
    skills: [{type: "anthropic", skill_id: "xlsx", version: "latest"}]
  },
  messages: [
    {
      role: "user",
      content: "Create a quarterly sales tracking spreadsheet with sample data"
    }
  ],
  tools: [{type: "code_execution_20260521", name: "code_execution"}]
)
```

--------------------------------

### Content review process feedback loop

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A validation loop pattern using reference documents to ensure style guide compliance.

```markdown
## Content review process

1. Draft your content following the guidelines in STYLE_GUIDE.md
2. Review against the checklist:
   - Check terminology consistency
   - Verify examples follow the standard format
   - Confirm all required sections are present
3. If issues found:
   - Note each issue with specific section reference
   - Revise the content
   - Review the checklist again
4. Only proceed when all requirements are met
5. Finalize and save the document
```

--------------------------------

### Create a presentation using TypeScript

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the TypeScript SDK to create a message with the PowerPoint skill and log the response details.

```typescript
// Create a message with the PowerPoint Skill
const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 16000,
  container: {
    skills: [{ type: "anthropic", skill_id: "pptx", version: "latest" }],
  },
  messages: [
    {
      role: "user",
      content: "Create a presentation about renewable energy with 5 slides",
    },
  ],
  tools: [{ type: "code_execution_20260521", name: "code_execution" }],
});

console.log(
  `stop_reason=${response.stop_reason}, blocks=${response.content.length}`,
);
```

--------------------------------

### Excel Analysis Skill Description

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Example of an effective description for an Excel analysis skill, including relevant file types and analytical tasks.

```yaml
description: Analyze Excel spreadsheets, create pivot tables, generate charts. Use when analyzing Excel files, spreadsheets, tabular data, or .xlsx files.
```

--------------------------------

### Download file using C# SDK

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses pattern matching to extract the file ID from the response and streams the file content to the local filesystem.

```csharp
// Extract the file ID. The code execution tool runs the Skill's code through
// its Bash sub-tool, and generated files appear as bash_code_execution_output
// items inside the bash_code_execution_tool_result block.
string? fileId = null;
foreach (var block in response.Content)
{
    if (block.TryPickBashCodeExecutionToolResult(out var bashResult)
        && bashResult.Content.TryPickBashCodeExecutionResultBlock(out var bashResultBlock))
    {
        foreach (var output in bashResultBlock.Content)
        {
            fileId = output.FileID;
        }
    }
}

if (fileId is not null)
{
    // Download the file and save it
    var outputPath = Path.Combine(Path.GetTempPath(), "renewable_energy.pptx");
    using var download = await client.Files.Download(fileId);
    await using var source = await download.ReadAsStream();
    await using var destination = File.Create(outputPath);
    await source.CopyToAsync(destination);
    Console.WriteLine($"Presentation saved to {outputPath}");
}
```

--------------------------------

### Deeply Nested Reference Anti-Pattern

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of a bad practice where references are chained across multiple files, which can lead to incomplete information retrieval.

```markdown
# SKILL.md
See [advanced.md](advanced.md)...

# advanced.md
See [details.md](details.md)...

# details.md
Here's the actual information...
```

--------------------------------

### Git Commit Helper Skill Description

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Example of an effective description for a Git commit helper skill, detailing the input source and user intent.

```yaml
description: Generate descriptive commit messages by analyzing git diffs. Use when the user asks for help writing commit messages or reviewing staged changes.
```

--------------------------------

### Create a presentation with the PowerPoint Skill in PHP

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses the PHP client to send a message with the 'pptx' skill and code execution tool enabled.

```php
// Create a message with the PowerPoint Skill
$response = $client->messages->create(
    model: 'claude-opus-5',
    maxTokens: 16000,
    container: [
        'skills' => [['type' => 'anthropic', 'skillID' => 'pptx', 'version' => 'latest']],
    ],
    messages: [
        [
            'role' => 'user',
            'content' => 'Create a presentation about renewable energy with 5 slides',
        ],
    ],
    tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
);

printf("stop_reason=%s, blocks=%d\n", $response->stopReason, count($response->content));
```

--------------------------------

### Create a presentation with the PowerPoint Skill in Ruby

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses the Ruby client to send a message with the 'pptx' skill and code execution tool enabled.

```ruby
# Create a message with the PowerPoint Skill
response = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 16_000,
  container: {
    skills: [{type: "anthropic", skill_id: "pptx", version: "latest"}]
  },
  messages: [
    {
      role: "user",
      content: "Create a presentation about renewable energy with 5 slides"
    }
  ],
  tools: [{type: "code_execution_20260521", name: "code_execution"}]
)

puts "stop_reason=#{response.stop_reason}, blocks=#{response.content.length}"
```

--------------------------------

### Medium freedom report generation template

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

An example of medium-freedom instructions using a Python function template with parameters for tasks where a preferred pattern exists.

```python
def generate_report(data, format="markdown", include_charts=True):
    # Process data
    # Generate output in specified format
    # Optionally include visualizations
```

--------------------------------

### Create a presentation with the PowerPoint Skill in Java

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses the Java client to send a message with the 'pptx' skill and code execution tool enabled.

```java
// Create a message with the PowerPoint Skill
Message response = client.messages().create(
    MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(16000)
        .container(
            ContainerParams.builder()
                .addSkill(
                    SkillParams.builder()
                        .type(SkillParams.Type.ANTHROPIC)
                        .skillId("pptx")
                        .version("latest")
                        .build()
                )
                .build()
        )
        .addUserMessage("Create a presentation about renewable energy with 5 slides")
        .addTool(CodeExecutionTool20260521.builder().build())
        .build()
);

IO.println(
    "stop_reason=" + response.stopReason().orElse(null)
        + ", blocks=" + response.content().size()
);
```

--------------------------------

### Create a Word document in Python

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Python client to create a message with the docx skill.

```python
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    container={
        "skills": [{"type": "anthropic", "skill_id": "docx", "version": "latest"}]
    },
    messages=[
        {
            "role": "user",
            "content": "Write a 2-page report on the benefits of renewable energy",
        }
    ],
    tools=[{"type": "code_execution_20260521", "name": "code_execution"}],
)
```

--------------------------------

### List Anthropic-managed Skills via Go

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Go SDK to list all Anthropic-managed Skills.

```go
// List Anthropic-managed Skills
skills, err := client.Skills.List(ctx, anthropic.SkillListParams{
	Source: anthropic.String("anthropic"),
})
if err != nil {
	panic(err)
}

for _, skill := range skills.Data {
	fmt.Printf("%s: %s\n", skill.ID, skill.DisplayName)
}
```

--------------------------------

### Create a Word document in C#

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the C# client to create a message with the docx skill.

```csharp
var response = await client.Messages.Create(
    new MessageCreateParams
    {
        Model = Model.ClaudeOpus5,
        MaxTokens = 16000,
        Container = new ContainerParams
        {
            Skills =
            [
                new SkillParams
                {
                    Type = SkillParamsType.Anthropic,
                    SkillID = "docx",
                    Version = "latest",
                },
            ],
        },
        Messages =
        [
            new MessageParam
            {
                Role = Role.User,
                Content = "Write a 2-page report on the benefits of renewable energy",
            },
        ],
        Tools = [new CodeExecutionTool20260521()],
    }
);
```

--------------------------------

### List Anthropic-managed Skills via CLI

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the ant CLI to list all Anthropic-managed Skills.

```bash
# List Anthropic-managed Skills
ant skills list --source anthropic
```

--------------------------------

### Use forward slashes for file paths

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Always use Unix-style forward slashes in file paths to ensure cross-platform compatibility, as Windows-style backslashes cause errors on Unix systems.

```text
scripts/helper.py
```

```text
reference/guide.md
```

--------------------------------

### Create a Word document in Java

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Java client to create a message with the docx skill.

```java
Message response = client.messages().create(
    MessageCreateParams.builder()
        .model(CLAUDE_OPUS_5)
        .maxTokens(16000)
        .container(
            ContainerParams.builder()
                .addSkill(
                    SkillParams.builder()
                        .type(ANTHROPIC)
                        .skillId("docx")
                        .version("latest")
                        .build()
                )
                .build()
        )
        .addUserMessage("Write a 2-page report on the benefits of renewable energy")
        .addTool(CodeExecutionTool20260521.builder().build())
        .build()
);
```

--------------------------------

### Generate a PDF using Go

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses the Anthropic Go SDK to generate a PDF invoice template.

```go
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 16000,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "pdf",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Generate a PDF invoice template")),
	},
	Tools: []anthropic.ToolUnionParam{
		{
			OfCodeExecutionTool20260521: &anthropic.CodeExecutionTool20260521Param{},
		},
	},
})
if err != nil {
	panic(err)
}
```

--------------------------------

### Reference MCP tools with fully qualified names

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Use the ServerName:tool_name format to ensure Claude can locate tools when multiple MCP servers are available.

```markdown
Use the BigQuery:bigquery_schema tool to retrieve table schemas.
Use the GitHub:create_issue tool to create issues.
```

--------------------------------

### Download file using TypeScript SDK

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Parses the response object for the file ID and uses the filesystem module to write the downloaded buffer to disk.

```typescript
// Extract the file ID. The code execution tool runs the Skill's code through
// its Bash sub-tool, and generated files appear as bash_code_execution_output
// items inside the bash_code_execution_tool_result block.
let fileId: string | undefined;
for (const block of response.content) {
  if (
    block.type === "bash_code_execution_tool_result" &&
    block.content.type === "bash_code_execution_result"
  ) {
    for (const output of block.content.content) {
      fileId = output.file_id;
    }
  }
}

if (fileId) {
  // Download the file and save it
  const outputPath = path.join(os.tmpdir(), "renewable_energy.pptx");
  const fileContent = await client.files.download(fileId);
  await fs.writeFile(outputPath, Buffer.from(await fileContent.arrayBuffer()));
  console.log(`Presentation saved to ${outputPath}`);
}
```

--------------------------------

### Create a presentation using cURL

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the cURL command to send a message to the Messages API with the PowerPoint skill enabled.

```bash
# Create a message with the PowerPoint Skill
response=$(
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d @- <<'EOF'
{
  "model": "claude-opus-5",
  "max_tokens": 16000,
  "container": {
    "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
  },
  "messages": [
    {"role": "user", "content": "Create a presentation about renewable energy with 5 slides"}
  ],
  "tools": [{"type": "code_execution_20260521", "name": "code_execution"}]
}
EOF
)
```

--------------------------------

### Skill Metadata YAML Frontmatter

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview

The YAML frontmatter provides discovery information loaded at startup. The description field is critical for Claude to determine when to trigger the skill.

```yaml
---
name: pdf-processing
description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
---
```

--------------------------------

### Create a Word document in PHP

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Uses the messages API with the 'docx' skill and code execution tool to generate a report.

```php
$response = $client->messages->create(
    model: 'claude-opus-5',
    maxTokens: 16000,
    container: [
        'skills' => [
            ['type' => 'anthropic', 'skillID' => 'docx', 'version' => 'latest'],
        ],
    ],
    messages: [
        [
            'role' => 'user',
            'content' => 'Write a 2-page report on the benefits of renewable energy',
        ],
    ],
    tools: [['type' => 'code_execution_20260521', 'name' => 'code_execution']],
);
```

--------------------------------

### Download file using Python SDK

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Iterates through the response content to find the file ID and uses the client to download and save the file.

```python
# Extract the file ID. The code execution tool runs the Skill's code through
# its Bash sub-tool, and generated files appear as bash_code_execution_output
# items inside the bash_code_execution_tool_result block.
file_id = None
for block in response.content:
    if block.type == "bash_code_execution_tool_result":
        if block.content.type == "bash_code_execution_result":
            for output in block.content.content:
                file_id = output.file_id

if file_id:
    # Download the file and save it
    output_path = Path(tempfile.gettempdir()) / "renewable_energy.pptx"
    file_content = client.files.download(file_id=file_id)
    file_content.write_to_file(output_path)
    print(f"Presentation saved to {output_path}")
```

--------------------------------

### List Anthropic-managed Skills via Python

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the Python SDK to list all Anthropic-managed Skills.

```python
# List Anthropic-managed Skills
skills = client.skills.list(source="anthropic")

for skill in skills.data:
    print(f"{skill.id}: {skill.display_name}")
```

--------------------------------

### List Anthropic-managed Skills via PHP

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart

Use the PHP SDK to list all Anthropic-managed Skills.

```php
// List Anthropic-managed Skills
$skills = $client->skills->list(source: 'anthropic');

foreach ($skills->getItems() as $skill) {
    echo "{$skill->id}: {$skill->displayName}\n";
}
```

--------------------------------

### Legacy API documentation pattern

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

A recommended way to document deprecated features using a details element to keep historical context separate.

```markdown
## Current method

Use the v2 API endpoint: `api.example.com/v2/messages`

## Old patterns

<details>
<summary>Legacy v1 API (deprecated 2025-08)</summary>

The v1 API used: `api.example.com/v1/messages`

This endpoint is no longer supported.
</details>
```

--------------------------------

### Utility script: fill_form.py

Source: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices

Command to apply field values to a PDF.

```bash
python scripts/fill_form.py input.pdf fields.json output.pdf
```
Tokens:
Raw