> ## Documentation Index
> Fetch the complete documentation index at: https://solidstate.cc/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Install a skill

> Install any Solid State skill on Claude Code, Hermes, OpenClaw, Codex, Cursor, OpenCode, or Cline — or run it over the Claude API. One folder, one SKILL.md.

Using an agent? Paste this and walk away:

```text theme={null}
Read https://solidstate.cc/docs/llms-full.txt and install a skill for me.
```

A skill is packaged judgment. Instructions that tell an agent how to think when it hits a task it's seen before.

Physically: a folder with a `SKILL.md` inside.

Installing means putting that folder where your agent looks. That's it.

Every runtime below reads the same [Agent Skills spec](https://agentskills.io). One skill, every agent. No rewrites.

## Claude Code

Drop the folder in your skills directory:

```bash theme={null}
# personal — available in every project
mkdir -p ~/.claude/skills
cp -r ./my-skill ~/.claude/skills/

# project — checked into the repo, shared with the team
mkdir -p .claude/skills
cp -r ./my-skill .claude/skills/
```

Claude loads it when the task matches the skill's description. No restart, no registration.

Plugins can bundle skills and install from marketplaces. See [Claude Code docs](https://docs.claude.com/en/docs/claude-code).

## Claude API

Skills also run server-side. No filesystem, no install step.

Three beta headers and a `container` block:

```python theme={null}
from anthropic import Anthropic

client = Anthropic(
    default_headers={
        "anthropic-beta": "code-execution-2025-08-25,files-api-2025-04-14,skills-2025-10-02"
    }
)

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    container={"skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]},
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[{"role": "user", "content": "Build the budget spreadsheet."}],
)
```

`type: "anthropic"` loads Anthropic's built-ins (docx, pdf, pptx, xlsx). Custom skills upload once via the [Skills API](https://docs.claude.com/en/api/skills-guide), then load by `skill_id` the same way. Same folder, same `SKILL.md` — zipped instead of copied.

Files the skill creates come back as `file_id`s. Download them via the Files API.

Working notebooks: [Anthropic's skills cookbook](https://github.com/anthropics/claude-cookbooks/tree/main/skills).

## Hermes Agent

Three rails. Pick one.

**Tap** — subscribe to the Solid State repo:

```bash theme={null}
hermes skills tap add solidstatecc/skills
hermes skills install solidstatecc/skills/publish-audit
```

**Well-known** — solidstate.cc is a discovery endpoint:

```bash theme={null}
hermes skills search https://solidstate.cc --source well-known
hermes skills install \
  well-known:https://solidstate.cc/.well-known/skills/publish-audit
```

**ClawHub** — an integrated Hermes source:

```bash theme={null}
hermes skills install clawhub/<skill-name>
```

Every rail runs Hermes' security scan. Community-source warnings are normal.

Or skip all three and drop a folder into `~/.hermes/skills/`.

## OpenClaw

Install from the ClawHub registry — Solid State publishes under the `solidstate` owner:

```bash theme={null}
npx clawhub install solidstate/<skill-name>
```

Or place the folder in your OpenClaw skills directory.

## Codex

```bash theme={null}
mkdir -p .codex/skills
cp -r ./my-skill .codex/skills/
```

Same spec, same layout.

## OpenCode

OpenCode reads Claude's skill paths directly. If a skill is in `.claude/skills/` or `~/.claude/skills/`, it already works.

Native paths also work:

```bash theme={null}
mkdir -p .opencode/skills
cp -r ./my-skill .opencode/skills/
```

Global: `~/.config/opencode/skills/`. It also reads `.agents/skills/`. No conversion, no config.

## Cursor, Cline

Both consume the Agent Skills spec. Place the skill folder in the runtime's skills directory and it loads on match. Check each tool's docs for the current path — these move fast.

## Everything else

Any spec-compliant runtime works the same way:

1. Get the skill folder (clone the repo, or download from the listing page).
2. Put it where your runtime reads skills.
3. Confirm `SKILL.md` sits at the folder root.

Done. The skill triggers when your task matches its description.

## Skills vs. MCP

Skills teach. MCP connects.

A skill is knowledge — how to think about a problem.
MCP is a tool channel — what the agent can reach.

You want both. They don't compete.

## Before you install

Skills are code. Treat them like code.

In February 2026, a popular skill pack shipped with planted instructions that stole API keys from the agents that installed it. Registries added scanners after. Scanners miss things.

Read the `SKILL.md`. Read every file that ships with it. Then install.

Every listing here shows its [provenance](/docs/licensing) for exactly this reason. It's a pointer you can follow. Follow it.

## Where the skills are

Browse the catalog at [solidstate.cc/skills](https://solidstate.cc/skills). Filter by runtime, category, or license.

Every listing links to its source repo. Originals are authored by Solid State. Listings point upstream — we index, we don't claim.

***

Installed one? Write one. → [Author a skill](/docs/authoring)