# explain-error

Adopt this skill: https://proskills.md/skills/other/brattlof-skillet-examples-explain-error

Page: https://proskills.md/skills/other/brattlof-skillet-examples-explain-error
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: examples/explain-error/SKILL.md
size: 706
upstream: https://github.com/brattlof/skillet/blob/main/examples/explain-error/SKILL.md

```text
---
name: explain-error
description: Explain a stack trace or error message and suggest concrete fixes.
---

# explain-error

Use this when the user pastes an error, a stack trace, or failing build output.

1. Find the actual failure: the first real error, not the cascade of messages after it.
2. Explain in plain language what it means and the most likely cause.
3. Point at the specific file and line when the trace gives one.
4. Suggest one or two concrete fixes, with the exact change to make.
5. If the cause is ambiguous, say what to check or run next to narrow it down.

Prefer the smallest fix that addresses the root cause over a workaround, and say so when
you are guessing rather than certain.
```

## File: README.md
upstream: https://github.com/brattlof/skillet/blob/main/README.md

````text
<div align="center">

<img src="assets/banner.webp" alt="skillet - package manager for MCP servers and Agent Skills for Claude Code, Cursor, Codex, and more" width="640">

# skillet

**A tiny, zero-dependency package manager for MCP servers, Agent Skills, and Claude Code commands, hooks, subagents, and output styles.**

*Search a curated registry and install MCP servers, skills, slash commands, hooks, subagents, and output styles with one command - into Claude Code, Cursor, Codex, Gemini CLI, Copilot, and Cline.*

[![CI](https://github.com/Brattlof/skillet/actions/workflows/ci.yml/badge.svg)](https://github.com/Brattlof/skillet/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
![Go](https://img.shields.io/badge/go-1.23%2B-00ADD8?logo=go)
![GitHub stars](https://img.shields.io/github/stars/Brattlof/skillet?style=social)

</div>

skillet installs **MCP servers** (Model Context Protocol), **Agent Skills** (the open
`SKILL.md` standard), and Claude Code slash commands, hooks, subagents, and output styles into
Claude Code, Cursor, OpenAI Codex, Gemini CLI, Copilot, and Cline - from a curated, verified
registry of 370+ entries. One static Go binary, no Node or npm.

<div align="center">
  <img src="assets/demo.gif" alt="skillet demo: search a registry and install a skill or MCP server into Claude Code with one command" width="700">
</div>

```console
$ skillet search example
NAME         DESCRIPTION                                                   TAGS
hello-skill  Minimal example skill that ships with skillet - install i...  example,starter,docs

$ skillet add hello-skill
Installing hello-skill from https://github.com/Brattlof/skillet ...
Installed hello-skill -> ~/.claude/skills/hello-skill

$ skillet add hello-skill --target agents
Installed hello-skill -> ~/.agents/skills/hello-skill   # Cursor, Codex, Gemini, Copilot

$ skillet list
NAME         KIND   INSTALLED  SOURCE                       STATUS
hello-skill  skill  a1b2c3d    github.com/Brattlof/skillet  tracking
```

---

## Why use skillet?

Copy-pasting skill folders by hand, hunting through random repos, never knowing what's worth
installing. `skillet` fixes that: search a curated registry and install with one command.

- One static binary, no dependencies. The registry ships embedded - no backend, no account.
- Curated from official and widely-used sources, with every link and package verified. No
  dead-link slop. Contributed entries follow the one rule: you've actually used it.
- Skills use the open [Agent Skills](https://agentskills.io) `SKILL.md` format, so they work
  across tools. Install for Claude Code (default) or for the shared `~/.agents/skills`
  directory with `--target agents`, which Cursor, Codex, Gemini CLI, and Copilot all read.

## Supported tools

skillet installs for Claude Code by default (`~/.claude/skills`, plus its commands, hooks,
subagents, and output styles). Add `--target agents` and skills go to the shared
`~/.agents/skills` directory that Cursor, OpenAI Codex, Gemini CLI, and GitHub Copilot all read.
MCP servers install into each client's own config (Claude Code, Cursor, Windsurf, Gemini CLI,
and Cline). Commands, hooks, subagents, and output styles are Claude Code specific; skills and
MCP servers are the cross-tool part.

## Install

```bash
# Go users
go install github.com/Brattlof/skillet/cmd/skillet@latest

# Or grab a binary from Releases
# https://github.com/Brattlof/skillet/releases
```

> Building from source: `git clone` this repo, then `go build -o skillet ./cmd/skillet`.

## Usage

```text
skillet add <name>[@ref]   Install any registry entry (optionally pinned)
skillet add <owner/repo/skill>
                           Install a community skill from skills.sh
skillet install            Restore everything from skillet.lock
skillet install --frozen   Verify the install matches skillet.lock (no changes)
skillet lock               Write skillet.lock from what is installed
skillet update [name]      Update an installed item, or all of them
skillet doctor             Check installed items for problems
skillet remove <name>      Remove an installed item
skillet list               List installed items
skillet search <query>     Search the registry, then skills.sh (--kind, --tag)
skillet info <name>        Show details of a registry entry or community skill
skillet trending           Show trending skills on skills.sh (--limit N)
skillet hot                Show skills rising on skills.sh in the last hour
skillet registry           Show every registry entry
skillet publish            How to publish your own skill
skillet completion <sh>    Output a bash, zsh, or fish completion script
skillet self-update        Update the skillet binary to the latest release
```

Add `--target agents` to any command to use `~/.agents/skills` instead of
`~/.claude/skills`, or set `SKILLET_TARGET=agents`. skillet never overwrites a file or
folder it did not install; pass `--replace` to `add` or `install` to allow it.

### Skills, commands, hooks, agents, output styles, and MCP servers

A registry entry has a `kind`: `skill` (the default), `command`, `hook`, `agent`,
`output-style`, or `mcp`. skillet installs each into the place the tool reads:

- a **skill** is a folder copied to `~/.claude/skills/<name>/` (or `~/.agents/skills/<name>/`
  with `--target agents`, the shared location Cursor, Codex, Gemini CLI, and Copilot read),
- a **command** is a single `.md` file copied to `~/.claude/commands/<name>.md`,
- a **hook** is a script copied to `~/.claude/hooks/`, and skillet registers it in
  `~/.claude/settings.json` under the event from the entry's `hook` block (and
  un-registers it on `remove`),
- an **agent** (subagent) is a single `.md` file copied to `~/.claude/agents/<name>.md`,
- an **output style** is a single `.md` file copied to `~/.claude/output-styles/<name>.md`,
- an **MCP server** is registered into a client's MCP config; `--target` picks the client.

Commands, hooks, agents, and output styles are Claude Code specific. Skills and MCP servers work across tools:

```bash
skillet add context7 --target cursor     # -> ~/.cursor/mcp.json
skillet add context7 --target windsurf   # -> ~/.codeium/windsurf/mcp_config.json
skillet add context7 --target claude     # -> ./.mcp.json (project scope)
skillet remove context7 --target cursor
```

Supported MCP clients: claude, cursor, windsurf, gemini, cline. skillet merges the
server into the existing config and leaves every other entry untouched.

### Shell completion

```bash
# bash (current shell)
source <(skillet completion bash)
# zsh
skillet completion zsh > "${fpath[1]}/_skillet"
# fish
skillet completion fish > ~/.config/fish/completions/skillet.fish
```

Completion suggests subcommands, the `--target` and `--dir` flags, and skill names pulled
from the local index, so it stays instant and works offline.

Choose where skills install, per-command or globally:

```bash
skillet add hello-skill --target agents          # ~/.agents/skills (cross-tool)
export SKILLET_TARGET=agents                      # make it the default
skillet add hello-skill --dir ~/somewhere/else    # an exact directory
```

### Community skills from skills.sh

The curated registry is small on purpose. For everything else, skillet also searches
[skills.sh](https://skills.sh), Vercel's open directory of Agent Skills:

```console
$ skillet search pdf
NAME  KIND   DESCRIPTION                                   TAGS
pdf   skill  Fill, create, merge, split, and extract ...  pdf,documents

From skills.sh (community, not reviewed by skillet):
SKILL                                       INSTALLS
openai/skills/pdf                           13.6k
github/awesome-copilot/pdftk-server         10.0k

$ skillet add openai/skills/pdf
audit: Gen Agent Trust Hub pass, Socket pass, Snyk warn (Risk: MEDIUM · 1 issue), ...
Installed open
````
