# How to Integrate Skills with Claude Code vs Claude.ai vs the Claude API

> Integrate Anthropic Skills with Claude Code, Claude.ai, and the API using a single manifest file. Learn how to invoke Skills across platforms with this guide.

- Repository: [Anthropic/skills](https://github.com/anthropics/skills)
- Tags: how-to-guide
- Published: 2026-02-16

---

**TLDR:** You can integrate Anthropic Skills across Claude Code (VS Code extension), Claude.ai (web interface), and the Claude API by registering a manifest file ([`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json)) that defines your Skill's ID, schema, and permissions, then invoking the Skill via platform-specific tool calls that all share the same underlying sandboxed execution model.

Anthropic Skills are reusable tools that extend Claude's capabilities across different interfaces. Whether you are building inside the `anthropics/skills` repository or consuming existing Skills, understanding how to integrate them with Claude Code, Claude.ai, and the Claude API requires knowledge of the shared manifest system and platform-specific invocation patterns.

## What Are Anthropic Skills?

Anthropic Skills are small, reusable pieces of functionality that Claude can invoke as **tools** during conversation. Each Skill is defined by a JSON-style manifest that specifies its unique identifier, input/output schemas, and execution permissions. When registered, Skills become available across Claude Code, Claude.ai, and the Claude API, allowing consistent functionality regardless of how you interact with Claude.

## The Central Manifest: opencode.json

The [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) file serves as the canonical configuration for Skills within the `anthropics/skills` repository. This manifest lives in the repository root and defines both the Skill catalog and the security sandbox.

According to the source code, the permission block in [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) explicitly denies all file system access except for the `/cache/repos/...` directory. This means Skills operate within a restricted environment where they cannot modify arbitrary files on the host system, ensuring consistent security across all three integration points.

## Integration Methods

### Claude Code (VS Code Extension)

Claude Code integrates Skills through the VS Code extension by reading the manifest URL from your workspace settings. The extension surfaces Skills as command palette actions or inline chat prompts that execute locally within the sandbox.

To configure Skills in Claude Code, add the repository URL to your [`.vscode/settings.json`](https://github.com/anthropics/skills/blob/main/.vscode/settings.json):

```json
{
  "claude.skills.manifest": "https://github.com/anthropics/skills/blob/main/opencode.json"
}

```

When you invoke a Skill through the command palette, Claude Code sends a chat request that includes the Skill in the tools field:

```json
{
  "tools": [{ "type": "skill", "name": "my-skill-id" }]
}

```

The extension handles the `tool_use` action locally, executing the Skill within the sandboxed environment defined by the permission block.

### Claude.ai (Web Interface)

Claude.ai consumes Skills through the web UI by loading the Skill catalog from the manifest URL. Skills appear in the **Tools** drawer, where they can be dragged into conversations or invoked by name.

To add a Skill in Claude.ai:

1. Open the **Tools** drawer and select **Add Skill**.
2. Paste the manifest URL: `https://github.com/anthropics/skills/blob/main/opencode.json`.
3. The UI lists available Skills by their unique IDs defined in the manifest.

When you invoke a Skill, Claude.ai sends a request similar to the API format:

```json
{
  "model": "claude-3-5-sonnet-20240620",
  "messages": [
    { "role": "user", "content": "Generate a summary using MySkill." }
  ],
  "tools": [{ "type": "skill", "name": "my-skill-id" }]
}

```

Claude processes the `tool_use` request, invokes the Skill, and returns the result as part of the assistant message.

### Claude API (Programmatic Access)

The Claude API provides direct HTTP access to Skills through the `tools` parameter in completion requests. This method offers the most control for backend integrations and automated workflows.

To call a Skill via the API, send a POST request to `https://api.anthropic.com/v1/complete` with the Skill specified in the tools array:

```bash
curl https://api.anthropic.com/v1/complete \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-3-5-sonnet-20240620",
    "messages": [
      {"role":"user","content":"Please run MySkill on this data."}
    ],
    "tools": [{"type":"skill","name":"my-skill-id"}]
  }'

```

The response includes a `tool_results` block containing the Skill output:

```json
{
  "type": "assistant",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "tool-123",
      "content": "Skill output goes here"
    }
  ]
}

```

Your application can parse the `tool_result.content` field to process the Skill's output, store results in a database, or trigger subsequent actions.

## Security and Sandboxing

All three integration methods enforce the same security model defined in the [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) permission block. According to the `anthropics/skills` source code, Skills are restricted to read/write access within the `/cache/repos/...` directory only.

This sandboxing ensures that Skills cannot modify files outside the cache directory, regardless of whether they are invoked from Claude Code, Claude.ai, or the Claude API. The uniform permission model guarantees predictable behavior and security across local development, web UI, and programmatic access.

## Summary

- **Claude Code** integrates Skills through VS Code extension settings, surfacing them as command palette actions that execute locally within the sandboxed cache directory.
- **Claude.ai** loads Skills from the manifest URL into the web UI's Tools drawer, allowing drag-and-drop invocation in conversations.
- **Claude API** enables programmatic Skill invocation via HTTP POST requests with the `tools` parameter, returning structured `tool_results` for backend processing.
- All methods rely on the [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) manifest for Skill definition and enforce sandboxed execution restricted to the `/cache/repos/...` directory.

## Frequently Asked Questions

### What is the difference between Claude Code and Claude.ai for skill integration?

Claude Code is a VS Code extension that executes Skills locally on your machine within the sandboxed environment, while Claude.ai is a web-based interface that processes Skills through Anthropic's cloud infrastructure. Claude Code surfaces Skills as command palette actions and inline chat prompts, whereas Claude.ai presents them in a Tools drawer for drag-and-drop conversation integration.

### How do I register a custom skill with Anthropic?

To register a custom Skill, create an [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) manifest file in your repository root that defines the Skill's unique ID, input/output JSON schemas, and permissions. Upload or reference this manifest URL in Claude Code settings, Claude.ai's Add Skill dialog, or include it in your API client configuration. The manifest serves as the canonical source for Skill discovery across all three platforms.

### Can skills modify files outside the cache directory?

No, Skills cannot modify files outside the `/cache/repos/...` directory. The permission block in [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) explicitly denies all other file system access, creating a sandboxed environment that applies uniformly across Claude Code, Claude.ai, and the Claude API. This restriction ensures Skills operate safely without risking arbitrary file modifications on host systems.

### Do I need different manifests for Claude Code vs the API?

No, you do not need different manifests. All three integration methods—Claude Code, Claude.ai, and the Claude API—consume the same [`opencode.json`](https://github.com/anthropics/skills/blob/main/opencode.json) manifest format. The manifest defines Skills once, and each platform interprets the schema, permissions, and execution environment according to its specific interface requirements, ensuring consistency across local development, web UI, and programmatic access.