DEV Community: Skillsboard

Cursor skills: what they are and how to use them

Tommaso — Tue, 18 Aug 2026 13:19:35 +0000

Publisher: Skills Board. Published August 15, 2026. Last checked August 15, 2026.

Cursor skills are folders of instructions that Cursor's agent loads when a task matches what the folder is for. Each holds a SKILL.md file and, optionally, the scripts, references, and assets the task needs. Cursor's own documentation opens by calling Agent Skills an open standard for extending AI agents, not a Cursor feature, which is the most useful thing to know before you write one.

That matters because the file you write is the file the other agents read. The format was originally developed by Anthropic and released as an open standard, the specification lives at agentskills.io, and Cursor appears in the client showcase there alongside Claude Code, Codex, and a long list of others.

This page covers what Cursor actually reads, every directory it scans including the Claude and Codex ones, the frontmatter fields it documents and the ones it does not, how to add a skill in a few minutes, what carries over when the same file moves between agents, what a team decides once more than one person depends on a skill, and the parts Cursor has not documented.

In short

A Cursor skill is a directory containing a SKILL.md file: YAML frontmatter with a name and a description, then Markdown instructions. Cursor discovers skills from its skill directories when it starts, presents them to the agent, and the agent decides when each one is relevant based on context.

Cursor describes skills as portable, version-controlled, actionable, and progressive: any agent that supports the standard reads the same file, a skill is just files you can commit, it can bundle scripts, templates, and references the agent runs or reads with its own tools, and those resources load on demand rather than sitting in context.

There are two ways to reach a skill. The agent picks one implicitly when your request matches its description, which is why the description has to say what the skill does and when to use it, in the words someone would actually type. You can also invoke one explicitly by typing a forward slash in Agent chat and searching its name.

Cursor also ships built-in skills that appear alongside the ones you add, among them /create-skill for authoring a new one, /review and /review-security for code review, and /migrate-to-skills for converting rules and slash commands you already have. The full list is in Cursor's skills documentation.

Where Cursor looks for skills

Cursor loads skills from four of its own directories, two project-level and two user-level, and then, for compatibility, from four more that belong to other agents. That last part is the detail people coming from Claude Code or Codex do not expect, and it is documented rather than folklore.

Location	Scope	What it is for
.agents/skills/	Project	The vendor-neutral project directory. The same path Codex documents, so a repository that uses it serves both agents from one folder.
.cursor/skills/	Project	Cursor's own project directory, next to .cursor/rules and the rest of the Cursor configuration checked into the repository.
~/.agents/skills/	User	Personal skills that apply to every project you open, in the vendor-neutral location.
~/.cursor/skills/	User	Personal skills in Cursor's own home directory, for anything you do not want to place in the shared one.
.claude/skills/ and ~/.claude/skills/	Compatibility	Cursor documents loading skills from the Claude directories as well, so a repository already set up for Claude Code needs no second copy.
.codex/skills/ and ~/.codex/skills/	Compatibility	Cursor lists these as the Codex directories, although OpenAI documents .agents/skills rather than .codex/skills. See the limits section below.

Category folders are free. Cursor walks the skills root recursively and picks up any SKILL.md it finds, so you can group skills under shipping/, debugging/, or workflow/ subfolders. The category folder is organizational only: identity comes from the folder that directly contains SKILL.md.

Nested project directories are scoped automatically. A .cursor/skills/ or .agents/skills/ folder anywhere inside the repository is picked up, and Cursor documents that its skills surface only when the agent works with files inside that directory. In a monorepo, a skill in apps/web/.cursor/skills/ applies to apps/web while the repo-wide folder applies everywhere, with no frontmatter needed.

You can see what was actually found. Open Customize in the sidebar and go to Skills, where skills from a plugin or from the project appear alongside rules in the Agent Decides section, filterable by user, workspace, or team scope.

The SKILL.md fields Cursor documents

Two fields are required and the rest are optional. Two of the optional ones are Cursor's own additions to the standard, and they are the reason a Cursor skill can behave differently from the identical file read by another agent.

Field	Required	What it does
name	Yes	The skill identifier. Lowercase letters, numbers, and hyphens only, and it has to match the parent folder name. The Agent Skills specification adds the constraints every client shares: at most 64 characters, no leading or trailing hyphen, no consecutive hyphens.
description	Yes	What the skill does and when to use it. Cursor states plainly that the agent uses this field to determine relevance, so it is the field that decides whether the skill ever fires. The specification caps it at 1024 characters.
paths	No	Glob patterns that scope the skill to matching files, as a comma-separated string or a list. When set, Cursor surfaces the skill only while the agent is reading or editing files that match, which keeps file-specific guidance out of unrelated work.
disable-model-invocation	No	Set it to true and the skill behaves like a traditional slash command: it enters context only when you type its name after a forward slash, and the agent will not apply it on its own.
metadata	No	An arbitrary key-value mapping. This one is in the Agent Skills specification too, which describes it as a map from string keys to string values that clients can use for properties the spec does not define.
globs	No	The legacy spelling of paths. Cursor documents that it is still accepted as a fallback for older skills, and that new skills should use paths instead.

The body below the frontmatter is plain Markdown with no format restrictions, and all of it is read once the agent activates the skill. The specification recommends keeping SKILL.md under 500 lines and moving detailed reference material into separate files that load only when the instructions ask for them. Three of the six spec fields, license, compatibility, and allowed-tools, are absent from Cursor's table entirely, which the limits section below covers.

Skills are not rules, and Cursor is explicit about the split. Rule contents are included at the start of the model context; the 2.4 release note frames skills as better for dynamic context discovery and procedural how-to instructions. The built-in /migrate-to-skills converts eligible dynamic rules into skills, and slash commands into skills with disable-model-invocation set to true.

For the same field-by-field walkthrough on the OpenAI side, including the directories Codex scans and its separate agents/openai.yaml metadata file, see Codex skills: what they are and how to use them.

Cursor skills, Claude skills, and Codex skills: what actually transfers

The file transfers, and in Cursor's case more of the setup transfers than anywhere else, because Cursor is the only one of the three that documents reading the other two products' directories. What does not transfer is everything each product added on top of the standard.

Area	Cursor	Claude Code	Codex
Project directory	.cursor/skills/ and .agents/skills/, plus .claude/skills/ and .codex/skills/ for compatibility	.claude/skills/, including nested ones below the working directory	.agents/skills/, scanned from the working directory up to the repository root
Personal directory	~/.cursor/skills/ and ~/.agents/skills/, plus ~/.claude/skills/ and ~/.codex/skills/	~/.claude/skills/	$HOME/.agents/skills
Explicit invocation	Type a forward slash in Agent chat and search the skill name	Type a forward slash and the skill name	/skills, or $ and the skill name
Turning off automatic use	disable-model-invocation: true in the SKILL.md frontmatter	Claude Code frontmatter fields for invocation control	allow_implicit_invocation in a separate agents/openai.yaml file
File scoping	paths globs in the frontmatter, or a nested project skills directory	Nested .claude/skills/ directories below the working directory	Directory position, since Codex scans from the working directory upward
Distribution	Agent Plugins and Cursor Plugins, from the marketplace or a team marketplace	Plugins and plugin marketplaces	Plugins published to the directory shared by ChatGPT and Codex, plus marketplace files

Stay inside the specification and the file travels. It defines six frontmatter fields: name and description required, plus optional license, compatibility, metadata, and allowed-tools, the last marked experimental with support that varies. Anything outside that set is a product extension, so a skill that depends on paths or disable-model-invocation loses that behavior in an agent that does not read them.

Cursor reading the other directories removes a chore, not a difference. A repository set up for Claude Code works in Cursor with no second folder, but the reverse is not documented: neither Claude Code nor Codex documents reading .cursor/skills. For one folder that all three read, .agents/skills is the path Cursor and Codex both document, and Claude Code still needs .claude/skills or a symlink to it.

Portability is about the format, not the result. The same instructions can load in three products and still produce different work, because the tools, the sandboxing, the models, and the surrounding instructions differ. Test the skill in each agent your teammates actually run before you tell them it works there.

For the Claude side of the same standard, including the full frontmatter table and the surfaces skills run on, see Claude skills: what they are and how to use them.

How to add a skill to Cursor, step by step

There are three documented ways to end up with a skill Cursor can use: write the folder yourself, install a plugin that bundles skills, or ask a built-in skill to draft one for you. The manual path is worth learning first, because the other two produce the same thing on disk.

Decide which directory the skill belongs to

A skill everyone in the repository should have goes in .cursor/skills/ or .agents/skills/ at the project root. Pick .agents/skills/ if teammates also run Codex, since both products document it. A skill that is yours alone goes in ~/.cursor/skills/ or ~/.agents/skills/. A skill for one package in a monorepo goes in that package's own skills directory, where Cursor scopes it automatically.

Create the folder and the SKILL.md file

Make a directory named after the skill and put a SKILL.md file inside it. The frontmatter needs name and description. The name has to match the parent directory name and use lowercase letters, numbers, and hyphens, and the specification caps it at 64 characters with no leading, trailing, or consecutive hyphens.

Write the description for the trigger, not for the reader

Cursor states that the agent uses the description to determine relevance, so this field decides whether the skill ever fires. Say what it does and when to use it, in the words someone would actually type. A description that reads like a table of contents entry will not trigger.

Put the steps in the body and the bulk in separate files

The body is plain Markdown with no format restrictions. Keep SKILL.md under 500 lines, and move long reference material into references/, executable code into scripts/, and templates into assets/. Those load only when the instructions ask for them, which is the whole point of the format.

Scope it if it only applies to some files

Add a paths glob when the skill is about React components, Python style, or one package's conventions, and Cursor surfaces it only while the agent works with matching files. A skill placed in a nested project skills directory gets that scoping with no frontmatter at all.

Invoke it explicitly the first time

Type a forward slash in Agent chat and search for the skill name. Explicit invocation confirms Cursor found the folder and parsed the frontmatter. After that, leave it to the agent and see whether your description actually triggers on the requests you expected. Customize, then Skills, shows what Cursor discovered.

Or skip authoring entirely

The built-in /create-skill drafts a skill including its structure and SKILL.md, and /migrate-to-skills converts eligible dynamic rules and slash commands you already have. Installing a plugin from the Cursor Marketplace or a team marketplace brings its bundled skills with it, packaged under a skills/ directory with a SKILL.md per skill.

---
name: release-notes
description: Draft release notes from merged pull requests. Use when the user asks for release notes, a changelog entry, or a summary of what shipped.
---

## Steps

1. List the merged pull requests since the last tag.
2. Group them into features, fixes, and internal changes.
3. Write one line per user-visible change, in plain language.
4. Leave internal refactors out unless they change behavior.

## Output

A Markdown section titled with the version and date.

How teams keep one recommendation across Cursor and other agents

Two problems hide behind one word. Distribution is getting the files onto each teammate's machine. Recommendation is knowing which skill to use for a task and why that one. Cursor has good answers for the first. The second is not a Cursor problem at all.

If every skill your team uses lives in a repository everyone works in, the answer is short: commit them to .cursor/skills/ or .agents/skills/ at the project root and Cursor picks them up with no extra tooling. That is the best setup for a single-repository team, and no shared library improves on it. Nothing here should talk you out of it.

It stops being enough when the skills come from other people's repositories, when they are useful in more than one repository, or when teammates run different agents. Cursor's answer to the first two is plugins: it supports the Agent Plugins standard alongside its own Cursor Plugin format and offers team marketplaces on Teams and Enterprise plans with per-plugin install modes. That covers packaging and rollout, but not teammates outside Cursor, because a Cursor Plugin is not what Claude Code or Codex installs.

The recommendation layer usually has no home at all. Which skill the team settled on, and why, ends up in a chat thread, a bookmark, or one person's memory. Skills Board is a shared library for that layer: the smaller set of skills your team recommends, in one searchable place, with the original source visible on every entry, and no assumption about which agent a teammate runs.

Paths

Open the original source: Every saved skill records the repository and path it came from, so a teammate can read the SKILL.md before placing it.
Copy an install command: For the teammates whose setup the command fits. It is one option among several, not the only path.
Download a ZIP: The latest files available from the source at download time, for anyone who would rather place the folder themselves, in .cursor/skills or anywhere else Cursor scans.
Connect Cursor over MCP: Add the Skills Board MCP endpoint to .cursor/mcp.json in a project or ~/.cursor/mcp.json to use it everywhere, then sign in from Cursor's MCP settings. The agent can search the same team library and retrieve install commands, and with the granted scopes save skills and organize collections. Sign-in happens in the browser, with no API key to copy.

Limits

A saved skill is a team recommendation, not a security review, an approval, or a compatibility certification.
Skills Board follows the latest version available from the saved source. It does not pin or preserve historical versions.
The MCP connection cannot install or run a skill inside Cursor, and it cannot edit or delete saved team skills.
It is not a replacement for a skills directory. The files still have to land somewhere Cursor scans, by whichever route each teammate prefers.
The hosted product is free forever, the code is MIT licensed, and you can read or self-host all of it.

The operational version of this, with one canonical source and a tested install path per agent, is in Manage skills across Claude Code, Codex, and Cursor.

Limits and open questions

Some of what people expect to be documented is not. These are the gaps we found while reading Cursor's current documentation, written out rather than guessed at.

Precedence between the eight directories is not documented

Cursor lists four of its own skill directories and four compatibility ones, but does not say what happens when the same skill name appears in two of them. Claude Code documents a precedence order, and OpenAI documents that Codex does not merge same-named skills and may show both. Cursor documents neither, so treat duplicate names as untested.

Three optional specification fields are not documented for Cursor

The Agent Skills specification defines license, compatibility, metadata, and allowed-tools as optional, and marks allowed-tools experimental with support that varies between implementations. Cursor's frontmatter table documents metadata but not license, compatibility, or allowed-tools. Their behavior in Cursor is unverified.

Cursor lists .codex/skills, and OpenAI does not

Cursor names .codex/skills/ and ~/.codex/skills/ as the Codex compatibility directories. OpenAI documents .agents/skills from the working directory up to the repository root, $HOME/.agents/skills, and /etc/codex/skills. The overlap both products document is .agents/skills, so that is the safer choice for one folder serving Cursor and Codex.

There is no documented context budget for the skill list

Cursor describes progressive loading, but publishes no number for how much context the discovered skill list may take, or what happens when many skills are installed. OpenAI publishes a figure for Codex. Cursor does not, so how many skills you can keep installed is something you observe rather than look up.

The GitHub import path is documented through the rules flow

Cursor's skills page says you can import skills from GitHub through Customize, Rules, Add Rule, Remote Rule (Github). Its rules page describes that same flow as scanning the repository for .mdc files and importing them into .cursor/rules/imported/. How a SKILL.md folder ends up in a skills directory is not spelled out, so check the result in Customize, then Skills, before relying on it.

Only the editor and the CLI are named as surfaces

The 2.4 release note says Cursor supports Agent Skills in the editor and the CLI. The current Cloud Agents documentation does not mention skills, and neither does the agent overview page. Whether every Cursor surface loads a skill committed to a repository is not stated, so do not assume it.

Frequently asked questions

What is a Cursor skill?

A Cursor skill is a folder containing a SKILL.md file with YAML frontmatter and Markdown instructions. The frontmatter needs a name and a description. Cursor discovers skills from its skill directories at startup and presents them to the agent, which decides when each one is relevant. You can also invoke one by typing a forward slash in Agent chat.

Where do you put skills in Cursor?

Cursor loads project skills from .cursor/skills/ and .agents/skills/, and user-level skills from ~/.cursor/skills/ and ~/.agents/skills/. For compatibility it also loads from .claude/skills/, .codex/skills/, ~/.claude/skills/, and ~/.codex/skills/. Nested skills directories inside the repository are picked up too, scoped to the files under them.

Does Cursor read Claude skills?

Yes. Cursor documents loading skills from the Claude and Codex directories for compatibility: .claude/skills/, .codex/skills/, ~/.claude/skills/, and ~/.codex/skills/. The format is the same Agent Skills standard, so a repository already set up for Claude Code needs no second copy. Frontmatter fields specific to one product still do not carry over.

What is the difference between Cursor skills and Cursor rules?

Rules are declarative and always on: their contents enter the model context at the start. Skills load on demand, when the agent judges the description relevant or you invoke them. Cursor's 2.4 release note frames skills as better for dynamic context discovery and procedural how-to instructions, and ships /migrate-to-skills to convert eligible rules and slash commands.

How do you install a skill in Cursor?

Three documented paths. Create the folder yourself with a SKILL.md inside a directory Cursor scans. Install a plugin that bundles skills, from the Cursor Marketplace or a team marketplace. Or import from a GitHub repository through Customize, Rules, Add Rule, Remote Rule (Github). Check the result under Customize, then Skills.

Can you stop Cursor from using a skill automatically?

Yes. Set disable-model-invocation to true in the frontmatter and the skill behaves like a traditional slash command: it enters context only when you type its name after a forward slash. To narrow rather than disable automatic use, set a paths glob so the skill surfaces only on matching files.

How does a team share Cursor skills?

For one repository, commit them to .cursor/skills/ or .agents/skills/ and Cursor picks them up. Across repositories, Cursor distributes skills through plugins and team marketplaces on Teams and Enterprise plans. What neither covers is which skill the team recommends and why, especially when teammates run different agents, which is the layer a shared library like Skills Board holds.

Sources

Cursor: Agent Skills: The skill directories including the Claude and Codex compatibility paths, nested and category folders, the frontmatter table, the optional directories, the built-in skills, the Customize view, the GitHub import path, and /migrate-to-skills.
Cursor 2.4: Subagents, Skills, and Image Generation: The release that introduced Agent Skills in the Cursor editor and CLI, and the framing of skills against always-on rules.
Cursor: Plugins: What plugins bundle, the Agent Plugins standard alongside Cursor Plugins, team marketplaces and their install modes, and managing skills from Customize.
Cursor: Plugins reference: The skills format inside a plugin: one directory per skill under skills/, each with its own SKILL.md.
Cursor: Rules: How rule contents enter the model context, and the Remote Rule (Github) import flow that scans a repository for .mdc files.
Cursor: Customize Cursor: The Customize page, where skills, plugins, and MCP servers are managed at user, team, or workspace scope.
Agent Skills specification: The six frontmatter fields and their constraints, the optional scripts, references, and assets directories, and the progressive disclosure and file-size recommendations.
Agent Skills: overview and client showcase: The format as an open standard originally developed by Anthropic, and the showcase entry listing Cursor among the products that read it.
Claude Code: skills documentation: Where Claude Code loads skills from, its precedence order, and nested project skills.
OpenAI: build skills for ChatGPT and Codex: The directories Codex scans, its invocation syntax, its agents/openai.yaml file, and the published budget for the initial skill list.

Related resources

Originally published at skillsboard.sh/cursor-skills.

Codex skills: what they are and how to use them

Tommaso — Tue, 18 Aug 2026 13:18:59 +0000

If you run OpenAI's Codex and want to know exactly what the skill system does, and where the documentation stops, here is a full walkthrough of the format, the directories it scans, and the gaps we could not confirm.

Codex skills are folders of instructions that OpenAI's coding agent loads when a request matches what the folder is for. Each folder holds a SKILL.md file and, optionally, the scripts, reference documents, and templates the task needs. OpenAI's documentation calls skills the authoring format for reusable workflows, and plugins the way to distribute them.

The format is not specific to Codex. It is the Agent Skills standard, originally developed by Anthropic and released as an open standard, and the client showcase at agentskills.io lists ChatGPT and Codex among the products that read the same SKILL.md file.

This page covers what Codex actually reads, the exact directories it scans, what carries over from a Claude skill and what does not, how to add a skill in a few minutes, what a team has to decide once more than one person depends on the same skill, and the parts OpenAI has not documented.

Publisher: Skills Board. Published August 15, 2026. Last checked August 16, 2026.

In short

A Codex skill is a directory containing a SKILL.md file: YAML frontmatter with a name and a description, then Markdown instructions. Codex lists the name, description, and file path at startup, and reads the full file when it picks the skill.

That loading order is the point of the format. OpenAI calls it progressive disclosure: ChatGPT and Codex start from each skill's name and description, then load the full SKILL.md instructions when they decide to use that skill. Bundled scripts, references, and assets are read only when the instructions call for them, so a folder of installed skills costs very little context until one of them is relevant.

Codex can reach a skill in two ways. You can invoke it explicitly, with /skills or by typing $ and mentioning the skill in Codex CLI and the IDE extension, or in ChatGPT by typing @. Codex can also pick a skill implicitly when your task matches the skill description, which is why the description has to say both what the skill does and when it should trigger, in the words someone would actually type.

Where Codex looks for skills

Codex reads skills from repository, user, admin, and system locations. The repository scope is the one that surprises people coming from another agent: Codex scans a directory named .agents/skills in every directory from your current working directory up to the repository root.

Scope	Location	What it is for
Repo	$CWD/.agents/skills	The directory you launched Codex from. Skills that belong to one module or one service, checked in next to the code they describe.
Repo	$CWD/../.agents/skills	A folder above the working directory when you launch Codex inside a Git repository, for skills shared by a group of nested folders.
Repo	$REPO_ROOT/.agents/skills	The topmost folder of the Git repository. Root skills are available to any subfolder, which is where a team usually puts the ones everyone needs.
User	$HOME/.agents/skills	Personal skills that apply to every repository you work in, whether or not your teammates have them.
Admin	/etc/codex/skills	A shared system location on the machine or container, for SDK scripts, automation, and defaults an administrator wants every user on that machine to have.
System	Bundled with Codex	Skills OpenAI ships with the product, such as the skill creator and the plan skills. Available to everyone when they start Codex.

Names are not merged across locations. OpenAI documents that if two skills share the same name, Codex does not merge them and both can appear in skill selectors. That is a real difference from the precedence rules other agents apply, and it means a personal skill and a repository skill with the same name coexist rather than one silently winning.

Symlinked skill folders work. Codex follows the symlink target when it scans these locations, which is how one checked-out copy of a skill can serve several repositories without being duplicated in each of them.

The initial list is budgeted. In Codex the startup list includes each skill's name, description, and file path, and it is capped at 2% of the model's context window, or 8,000 characters when the context window is unknown. If many skills are installed, Codex shortens descriptions first, and for large skill sets it may leave some skills out of the initial list and show a warning. The budget applies only to that list: once Codex selects a skill, it still reads the full SKILL.md.

You can turn a skill off without deleting it. A [[skills.config]] entry in ~/.codex/config.toml takes the path to the skill folder containing SKILL.md and an enabled flag, and the config reference documents both keys. Restart Codex after changing the file.

Codex detects skill changes automatically, and OpenAI's instruction when an update does not show up is to restart Codex. The same applies to skills you have just installed.

Codex skills and Claude skills: what actually transfers

The file transfers. The setup around it does not. Both products implement the same Agent Skills standard, so a SKILL.md written for one is usually readable by the other, but the directories, the invocation syntax, and every field beyond the standard are product specific.

Area	Codex	Claude Code	What that means
Skill file	SKILL.md with name and description in the frontmatter	SKILL.md with name and description in the frontmatter	The same file. Both products document the Agent Skills standard as the format they read.
Repository location	.agents/skills, scanned from the working directory up to the repository root	.claude/skills, at the project root and in nested directories	A repository that serves both agents carries both directories, or one of them is a symlink to the other. Both products document following symlinks.
Personal location	$HOME/.agents/skills	~/.claude/skills	Two folders per teammate, kept current by hand.
Explicit invocation	/skills, or $ and the skill name	/ and the skill name	Instructions that tell a reader to type a slash command are agent specific. Skill bodies that name their own invocation syntax need editing per agent.
Implicit invocation	On by default, and can be turned off per skill with allow_implicit_invocation in agents/openai.yaml	Controlled by Claude Code frontmatter fields	The switch exists on both sides but lives in a different file, so the setting does not travel with the skill.
Extra fields	agents/openai.yaml for display metadata, invocation policy, and tool dependencies	Claude Code frontmatter such as invocation control, subagent execution, and dynamic context injection	Each product's extras are ignored or unknown outside it. The six fields in the Agent Skills specification are the portable set.
Distribution	Plugins, published to the plugin directory shared by ChatGPT and Codex, plus local and repository marketplaces	Plugins and plugin marketplaces	Two packaging systems with different manifests. A shared skill folder is portable; a packaged plugin is not.

Stay inside the specification and the file travels. The Agent Skills specification defines six frontmatter fields: name and description are required, and license, compatibility, metadata, and allowed-tools are optional. Anthropic documents that Claude Code accepts extra fields of its own and that only the six spec fields work outside Claude Code. OpenAI's Codex documentation describes name and description and its own agents/openai.yaml file, and does not document what Codex does with the four optional spec fields.

Portability is about the format, not the result. The same instructions can load in both products and still produce different work, because the tools, the sandboxing, and the surrounding instructions differ. Test the skill in each agent your teammates actually run before you tell them it works there.

For the same walkthrough from the Claude side, including the frontmatter table and the surfaces skills run on, see Claude skills: what they are and how to use them.

How to add a skill to Codex, step by step

There are three documented ways to end up with a skill Codex can use: write the folder yourself, install a curated one from inside Codex, or install a plugin that bundles skills. The manual path is the one worth learning first, because the other two produce the same thing.

Decide which scope the skill belongs to

A skill everyone working in the repository should have goes in .agents/skills at the repository root. A skill that only makes sense for one service goes in .agents/skills inside that service directory, because Codex scans every level from your working directory up to the root. A skill that is yours alone goes in $HOME/.agents/skills.

Create the folder and the SKILL.md file

Make a directory named after the skill and put a SKILL.md file inside it. The frontmatter needs name and description. The specification requires the name to match the parent directory name, to be at most 64 characters, and to use lowercase letters, numbers, and single hyphens.

Write the description for the trigger, not for the reader

The description is what Codex matches your request against, and it is also the part that gets shortened when many skills are installed. OpenAI's guidance is to write concise descriptions with clear scope and boundaries, and to front load the key use case and the trigger words so a host can still match the skill if descriptions are shortened.

Put the steps in the body, and the bulk in separate files

The body is plain Markdown with no format restrictions. The specification recommends keeping SKILL.md under 500 lines and moving detailed reference material into separate files, because the whole body is read once the skill activates while referenced files load only when the instructions ask for them.

Invoke it explicitly the first time

Run /skills in Codex CLI or the IDE extension and pick the skill, or type $ and mention it by name. Explicit invocation confirms Codex found the folder. After that, leave it to implicit matching and see whether your description actually triggers on the requests you expected.

Add optional metadata only if you need it

An agents/openai.yaml file inside the skill folder can set the display name, short description, icons, brand color, and default prompt shown in the ChatGPT desktop app, declare tool dependencies such as an MCP server, and set allow_implicit_invocation to false so the skill runs only when you invoke it explicitly.

Or skip authoring entirely

Inside Codex, $skill-creator drafts a skill by asking what it does, when it should trigger, and whether it needs scripts. Record and Replay captures a workflow you demonstrate and drafts a skill from it. $skill-installer followed by a curated skill name installs one of OpenAI's, and can be prompted to download skills from other repositories.

SKILL.md starting point

---
name: release-notes
description: Draft release notes from merged pull requests. Use when the user asks for release notes, a changelog entry, or a summary of what shipped.
---

## Steps

1. List the merged pull requests since the last tag.
2. Group them into features, fixes, and internal changes.
3. Write one line per user visible change, in plain language.
4. Leave internal refactors out unless they change behavior.

## Output

A Markdown section titled with the version and date.

How teams keep one recommendation across Codex and other agents

Two problems hide behind one word. Distribution is getting the files onto each teammate's machine. Recommendation is knowing which skill to use for a task and why that one. Codex has answers for the first. The second is not a Codex problem at all.

If every skill your team uses lives in a repository everyone works in, the answer is short: commit them to .agents/skills at the repository root, and Codex picks them up with no extra tooling. That is the best available setup for a single repository team, and no shared library improves on it. Nothing on this page should talk you out of it.

It stops being enough when the skills come from other people's repositories, when they are useful in more than one repository, or when teammates run different agents. Then distribution splits: OpenAI's answer is plugins, published to the plugin directory shared by ChatGPT and Codex, or a marketplace file checked into $REPO_ROOT/.agents/plugins/marketplace.json or kept personally at ~/.agents/plugins/marketplace.json and added with codex plugin marketplace add. Anthropic's answer is its own plugin system. Neither one carries the other's packaging.

Paths

Open the original source: Every saved skill records the repository and path it came from, so a teammate can read the SKILL.md before putting it anywhere.
Copy an install command: For the teammates whose setup the command fits. It is one option among several, not the only path.
Download a ZIP: The latest skill files available from the source at download time, for anyone who would rather place the folder themselves, including in .agents/skills.
Connect an agent over MCP: An authenticated MCP endpoint lets a compatible agent search the same team library and retrieve install commands, and, with the granted scopes, save skills and organize collections. Sign in happens in the browser, with no API key to copy.

Limits

A saved skill is a team recommendation, not a security review, an approval, or a compatibility certification.
Skills Board follows the latest version available from the saved source. It does not pin or preserve historical versions.
It does not install or run skills inside Codex, and it does not claim a skill behaves the same in every agent your team uses.
It is not a replacement for .agents/skills. The files still have to land in a location Codex scans, by whichever route each teammate prefers.
The hosted product is free forever, the code is MIT licensed, and you can read or self host all of it.

The operational version of this, with one canonical source and a tested install path per agent, is in Manage skills across Claude Code, Codex, and Cursor.

Limits and open questions

Some of what people expect to be documented is not. These are the gaps we found while checking OpenAI's current documentation, written out rather than guessed at.

The optional specification fields are not documented for Codex

The Agent Skills specification defines license, compatibility, metadata, and allowed-tools as optional fields, and marks allowed-tools experimental with support that varies between implementations. OpenAI's Codex skills documentation describes name and description and its own agents/openai.yaml file, and says nothing about what Codex does with the other four. Treat their behavior in Codex as unverified.

Codex does not document reading .claude/skills

The documented locations are .agents/skills from the working directory up to the repository root, $HOME/.agents/skills, /etc/codex/skills, and the skills bundled with Codex. A directory used by another agent is not among them, so a repository that serves both agents needs both paths present, whether by copying the folder or by symlinking it.

Standalone skills are listed for three surfaces

OpenAI documents standalone skills as available in the ChatGPT desktop app, Codex CLI, and the IDE extension, and skills bundled in plugins as also available in Chat and Work across ChatGPT on the web, desktop, and mobile. Other Codex surfaces are not listed for standalone skills, so do not assume a folder on your laptop is present wherever else Codex runs.

Two first party sources point at different repositories

The Codex skills documentation links openai/skills for examples, and the open source page lists it as the home of reusable skills for ChatGPT and Codex. The repository itself opens with a notice marking it deprecated and pointing to the OpenAI plugins repository for current Codex skill and plugin examples. Both pages were checked on the date above.

There is no documented ceiling on how many skills to install

The initial skill list is capped at 2% of the model's context window, or 8,000 characters when it is unknown, and Codex shortens descriptions and may omit skills beyond that, with a warning. The number of skills that fits depends on the model and on how long your descriptions are, so the practical limit is something you observe rather than look up.

Frequently asked questions

What is a Codex skill?
A Codex skill is a folder containing a SKILL.md file with YAML frontmatter and Markdown instructions. The frontmatter needs a name and a description. Codex loads the name, description, and file path at startup, then reads the whole file when your request matches the description or when you invoke the skill.

Where do you put skills for Codex CLI?
Codex scans .agents/skills in every directory from your working directory up to the repository root, so a repository skill goes in .agents/skills at the level that should own it. Personal skills go in $HOME/.agents/skills, and machine wide ones in /etc/codex/skills. Codex also ships bundled skills of its own.

Do Claude skills work in Codex?
The file usually does. Both products read the same SKILL.md format from the Agent Skills standard. The locations differ: Claude Code reads .claude/skills and ~/.claude/skills, Codex reads .agents/skills and $HOME/.agents/skills. Frontmatter beyond the six standard fields, and any agent specific body syntax, does not carry over.

How do you install a skill in Codex?
Three documented paths. Create the folder yourself with a SKILL.md inside a location Codex scans. Run $skill-installer followed by a curated skill name from inside Codex. Or install a plugin that bundles skills. Codex detects new skills automatically, and OpenAI says to restart it if one does not appear.

What is the difference between a Codex skill and AGENTS.md?
AGENTS.md is always on guidance: Codex builds an instruction chain when it starts, from your Codex home directory down to your working directory, and every task carries it. A skill loads on demand, only when the request matches its description or you invoke it, so it costs context only when it is relevant.

Sources

OpenAI: build skills for ChatGPT and Codex: The skill directory layout, progressive disclosure and the initial list budget, explicit and implicit invocation, the four location scopes, symlink support, duplicate names, the skill creator and installer, the [[skills.config]] switch, and agents/openai.yaml.
OpenAI: Codex config reference: The skills.config array and its path and enabled keys, and the feature flag that lets Codex prompt to install missing MCP dependencies for a skill.
Agent Skills specification: The six frontmatter fields and their constraints, the naming rules, the optional scripts, references, and assets directories, and the progressive disclosure and file size recommendations.
Agent Skills: overview and client showcase: The format as an open standard originally developed by Anthropic, and the showcase entry listing ChatGPT and Codex among the products that read it.
Claude Code: skills documentation: Where Claude Code loads skills from, slash command invocation, symlinked skill folders, and which frontmatter fields work outside Claude Code.
OpenAI: package your plugin: The plugin manifest and skills directory, the plugin directory shared by ChatGPT and Codex, repository and personal marketplace files, and the codex plugin marketplace commands.
OpenAI: custom instructions with AGENTS.md: How Codex builds its instruction chain at startup, from the Codex home directory down to the working directory, and merges the files it finds.
OpenAI: Codex open source components: Which parts of Codex are open source, including the CLI at openai/codex, and the repositories listed for skills and plugins.
openai/skills on GitHub: The curated, experimental, and system skill folders, the $skill-installer usage examples, per skill licensing, and the notice marking the repository deprecated in favor of openai/plugins.

Keep reading

Originally published at skillsboard.sh/codex-skills.

Claude Skills: what they are and how to use them

Tommaso — Tue, 18 Aug 2026 13:18:13 +0000

Claude Skills are reusable folders of instructions that Claude loads when a request matches what the skill is for. Each folder holds a SKILL.md file and, optionally, the scripts, reference documents, and templates the task needs. Anthropic describes them as reusable, filesystem-based resources that turn a general-purpose agent into a specialist.

The format is not Claude-only. Anthropic developed it and released it as an open standard, the specification lives at agentskills.io, and a client showcase there lists the agent products that read the same SKILL.md file.

This page covers the format, how a skill loads, where skills run today, how to install one, how to write one, where to find skills worth using, and what changes the moment more than one person on a team depends on them.

Create your team library · Read the source on GitHub

Publisher: Skills Board. Published August 12, 2026. Last checked August 15, 2026.

What is a Claude Skill?

A Claude Skill is a folder containing a SKILL.md file: YAML frontmatter with a name and a description, followed by Markdown instructions. Claude keeps only the name and description in context, then reads the full file when a request matches the description. Bundled scripts, references, and assets load only when they are needed.

Sources for this section

01 / Format

What is inside a Claude Skill?

A skill is a directory whose entry point is a SKILL.md file. The file opens with YAML frontmatter, and the Markdown that follows is what Claude reads once the skill is triggered. Two frontmatter fields are required, name and description. The specification defines four more, all optional.

SKILL.md frontmatter fields defined by the Agent Skills specification.

Field	Required	What it does
name	Yes	Up to 64 characters, lowercase letters, numbers, and hyphens only. It must match the parent directory name, cannot start or end with a hyphen, and cannot contain consecutive hyphens.
description	Yes	Up to 1024 characters. This is the field the agent matches a request against, so it has to say both what the skill does and when to use it, in the words someone would actually type.
license	No	The license that applies to the skill, either a license name or the name of a bundled license file.
compatibility	No	Up to 500 characters for environment requirements: the intended product, required system packages, or network access. Most skills do not need it.
metadata	No	A map of string keys to string values for properties the spec does not define, such as an author or a version.
allowed-tools	No	A space-separated list of pre-approved tools. The spec marks this field experimental, and support varies between agent implementations.

Skill directory

my-skill/
  SKILL.md        # required: frontmatter and instructions
  scripts/        # optional: code the agent can run
  references/     # optional: documentation loaded on demand
  assets/         # optional: templates and other static files

Everything beyond SKILL.md is optional. The specification suggests scripts for executable code, references for documentation the agent reads only when it needs it, and assets for templates and other static files. There is no restriction on the Markdown body itself.

Claude Code accepts extra frontmatter fields of its own, such as disable-model-invocation and argument declarations. Outside Claude Code, the claude.ai upload path, the Skills API, and Anthropic's packaging script accept only the six fields in the spec, and an unexpected key fails with a hard error rather than being ignored. Frontmatter that stays inside the spec loads everywhere, including Claude Code.

Sources for this section

02 / Loading

How does Claude decide to use a skill?

Through progressive disclosure. The agent loads a skill in stages, so a large collection of installed skills costs very little until one of them is actually relevant.

The three stages of progressive disclosure and what each one costs.

Stage	When it loads	Context cost	What loads
Metadata	At startup, for every installed skill	About 100 tokens per skill	The name and description from the frontmatter
Instructions	When a request matches the description	Under 5,000 tokens recommended	The Markdown body of SKILL.md
Resources	Only when referenced	Nothing until accessed	Bundled files. Reference files enter context when read, and scripts run through bash so only their output costs tokens

This is why the description carries more weight than any other line in the file. It is the only part of most skills that Claude sees before deciding whether to read the rest, so a description that says what the skill does without saying when to use it will sit unused.

The same mechanism explains the length guidance. The specification recommends keeping SKILL.md under 500 lines and moving detail into referenced files. In Claude Code the loaded body then stays in the conversation for the rest of the session, so every line you leave in the main file is a recurring cost rather than a one-time one.

Sources for this section

03 / Surfaces

Where do Claude Skills work?

Skills run in Claude Code, on claude.ai, and through the Claude API, and the same SKILL.md folder is read by a growing list of other agents. What changes between them is how a skill gets installed, who else can use it, and what the runtime allows.

How skills are installed, shared, and sandboxed on each surface.

Surface	How a skill gets there	Who can use it	Runtime
Claude Code	Filesystem directories: ~/.claude/skills//SKILL.md for personal skills, .claude/skills//SKILL.md for a project, a skills directory inside a plugin, or enterprise managed settings.	You, one repository, or everyone the plugin or managed settings reach.	The same network access as any other program on your computer.
claude.ai	Upload the skill as a zip file under Settings, then Features. Available on Pro, Max, Team, and Enterprise plans with code execution enabled.	The individual user. Custom skills are not shared organization-wide and cannot be centrally managed by admins.	Network access varies with user and admin settings.
Claude API	Reference a skill_id in the container parameter alongside the code execution tool and the skills-2025-10-02 beta header, or upload your own through the /v1/skills endpoints.	Workspace-wide. All workspace members can access uploaded skills.	A sandboxed container with no network access and no runtime package installation.
Other agents	Each product documents its own install path for the same SKILL.md folder. The client showcase on agentskills.io links to the instructions for each one.	Depends on the product.	Depends on the product.

Custom skills do not sync across surfaces. Anthropic documents this plainly: a skill uploaded to claude.ai is not available through the API, a skill uploaded through the API is not available on claude.ai, and Claude Code skills are filesystem-based and separate from both. Each surface is managed on its own.

Anthropic also ships pre-built skills for PowerPoint, Excel, Word, and PDF. Those are available on claude.ai and the Claude API, and they are not available in Claude Code.

Sources for this section

04 / Install

How do you install and run a Claude Skill?

Installing a skill means putting the folder where the agent looks for it. There is no package manager in the format itself, which is why each surface has its own path.

In Claude Code, drop the folder in a skills directory
Use ~/.claude/skills// to make a skill available in all your projects, or .claude/skills// to scope it to one repository and commit it with the code. Claude Code watches those directories and picks up an added or edited SKILL.md during the session, without a restart.
Invoke it yourself, or let Claude choose
A skill is available as a slash command named after its directory, and Claude can also load it on its own when a request matches the description. Add disable-model-invocation: true when only you should be able to trigger it, which is the sensible default for anything that deploys, commits, or sends a message.
On claude.ai, upload a zip
Custom skills are uploaded under Settings, then Features, on Pro, Max, Team, and Enterprise plans with code execution enabled. Each teammate does this for their own account, since claude.ai custom skills are per user.
Through the API, pass a skill_id
Skills run inside the code execution tool's container. Reference the skill by id in the container parameter and send the skills-2025-10-02 beta header. Add the files-api-2025-04-14 header when the container needs uploaded input files or produces files you want to download.
From a catalog, use that catalog's installer
npx skills add owner/repo installs from the skills.sh directory. /plugin marketplace add anthropics/skills registers Anthropic's repository as a plugin marketplace in Claude Code, and the document and example skill plugins install from there.

Sources for this section

05 / Authoring

How do you write your own Claude Skill?

Write the skill the same way you would brief a new teammate: say when the procedure applies, then give the steps, then link to the detail rather than pasting it.

Pick something you already repeat
Anthropic's own trigger for Claude Code is direct: create a skill when you keep pasting the same instructions, checklist, or multi-step procedure into chat, or when a section of CLAUDE.md has grown into a procedure rather than a fact.
Create the directory and the file
The directory name becomes the command you type in Claude Code, and it has to match the name in the frontmatter. SKILL.md is the entry point and the only required file.
Write the description for matching, not for reading
State what the skill does and when to use it, and include the words a person would type when they need it. A description that only names the skill gives the agent nothing to match against.
Keep the body short
The specification recommends staying under 500 lines and roughly 5,000 tokens, and moving longer material into files under references that load only when the task calls for them.
Move deterministic work into scripts
A script's code never enters the context window. Only its output does, which makes a bundled script cheaper and more reliable than asking the agent to regenerate the same logic each time.
Validate before you share it
The skills-ref reference library checks that the frontmatter is valid and that the naming rules hold: skills-ref validate ./my-skill. This catches the fields that fail on upload or packaging rather than at authoring time.
Decide the distribution scope
Commit .claude/skills/ for a project, ship a skills directory inside a plugin for a wider audience, or deploy organization-wide through managed settings. Each scope answers a different question about who should get the skill by default.

SKILL.md starting point

---
name: release-notes
description: Draft release notes from merged pull requests. Use when preparing a release, writing a changelog, or summarizing what shipped.
---

# Release notes

## Steps
1. List the pull requests merged since the last tag.
2. Group them into Added, Changed, and Fixed.
3. Write one line per change, in plain language, from the reader's point of view.
4. Link every entry to its pull request.

## Output
A Markdown section ready to paste into the release description.

Sources for this section

06 / Ecosystem

Where do you find Claude Skills worth using?

Start with sources that publish the files, so you can read a skill before you install it. These four cover most of what the ecosystem currently offers.

anthropics/skills

Anthropic's public repository for Agent Skills. It holds example skills across creative, technical, and enterprise tasks, the specification, and a skill template. Many of the skills are Apache 2.0. The document skills that power file creation in Claude are source-available rather than open source, and Anthropic publishes them as a reference for more complex skills. Register the repository as a Claude Code plugin marketplace with /plugin marketplace add anthropics/skills.

obra/superpowers

An MIT-licensed community project that packages a full software development methodology as composable skills, with a spec-first, plan-then-build workflow. It documents install paths for Claude Code and several other agents, and it is installable from the official Claude plugin marketplace.

skills.sh

Vercel's public directory of agent skills. It has a leaderboard ranked from anonymous telemetry collected by its CLI, topics, an official set, routine security audits, and packs that bundle several skills behind one install command. Skills install with npx skills add owner/repo, and the CLI is open source.

agentskills.io

The standard's own site: the specification, a quickstart, and a client showcase that links to the skill instructions for each agent product that supports the format. Useful when you need to check whether a skill will load in something other than Claude.

Read before you install. Anthropic's guidance is to use skills only from sources you trust, because a skill gives an agent new instructions and executable code, and a malicious one can direct the agent to call tools in ways the stated purpose does not suggest. If a skill comes from somewhere unfamiliar, audit every file in it, including scripts and anything it fetches from an external URL, and treat the decision the way you would treat installing software.

Sources for this section

07 / Teams

How does a team share the skills it recommends?

Nothing in the format does it for you. The SKILL.md folder is portable, but distribution is per surface, and the recommendation itself usually is not stored anywhere at all.

Look at what the surfaces actually offer a team. On claude.ai, custom skills belong to the individual user, are not shared organization-wide, and cannot be centrally managed by admins. Through the API, uploaded skills are workspace-wide. In Claude Code, a skill lives in a personal folder, in one repository, or in a plugin. None of those places holds the part teammates keep asking about: which skill to use for this, and why this one.

That part ends up in a chat thread, a bookmark, or one person's memory. Skills Board is a shared library for exactly that layer: the smaller set of skills your team recommends, in one searchable place, with the original source visible on every entry.

Open the original source
Every saved skill records the repository and path it came from, so a teammate can read the SKILL.md before using it.

Copy an install command
For the teammates whose setup the command fits.

Download a ZIP
The latest skill files available from the source at download time, for anyone who would rather place the folder themselves.

Connect an agent over MCP
An authenticated MCP endpoint lets a compatible agent search the same team library, retrieve install commands, and, with the granted scopes, save skills and organize collections. Sign-in happens in the browser, with no API key to copy.

A saved skill is a team recommendation, not a security review, an approval, or a compatibility certification.
Skills Board follows the latest version available from the saved source. It does not pin or preserve historical versions.
It does not install or run skills inside your agent, and it does not claim a skill works in every agent your team uses.
The hosted product is free forever, the code is MIT licensed, and you can read or self-host all of it.

Create your team library

Sources for this section

08 / Questions

Frequently asked questions

What is a Claude Skill?
A folder containing a SKILL.md file with YAML frontmatter and Markdown instructions. The frontmatter needs a name and a description; the description is what Claude matches a request against. The folder can also bundle scripts, reference documents, and assets that load only when the task needs them.

What is the difference between a skill and a prompt?
A prompt is a conversation-level instruction for one task. A skill is a reusable folder that loads on demand, so the same guidance does not have to be repeated across conversations. Anthropic draws that distinction directly in the Agent Skills overview.

Do Claude Skills work outside Claude?
Yes. Agent Skills is an open standard published at agentskills.io, and its client showcase lists agent products that read the same SKILL.md file. Frontmatter fields beyond the six in the spec, and Claude Code-only body features such as dynamic context injection, do not carry over.

Do custom skills sync between Claude Code, claude.ai, and the API?
No. Anthropic documents that custom skills do not sync across surfaces. A skill uploaded to claude.ai is not available through the API, an API skill is not available on claude.ai, and Claude Code skills are filesystem-based and separate from both. You manage each surface yourself.

How many skills can you install before context suffers?
Only the name and description of each installed skill load at startup, about 100 tokens per skill, so a large collection costs little until something triggers it. In Claude Code the body of a triggered skill stays in the conversation for the rest of the session, so the number that matters is how many you use at once, not how many you have.

Are Claude Skills safe to install?
Treat a skill like software you are about to run. Anthropic's guidance is to use skills only from sources you trust, and to audit every bundled file before using one from an unknown source, because a skill can direct an agent to execute code and call tools. Skills that fetch content from external URLs deserve extra scrutiny.

What is the difference between a skill and an MCP server?
A skill is a folder of instructions and resources the agent reads. MCP is a protocol for connecting an agent to external tools and data through a server. They answer different questions and are often used together: Skills Board publishes a team library over an authenticated MCP endpoint, while the skills themselves stay in SKILL.md folders at their original sources.

Where should a team keep the skills it recommends?
Wherever teammates will actually look. If every skill belongs to one repository the whole team works in, commit them to .claude/skills/ and stop there. If the recommendations come from other people's repositories and teammates run different agents, a shared library that keeps the source visible on every entry is easier to keep current. Skills Board is one option, and it is free and open source.

Sources

Editorial method: every claim about the format and the products that run it comes from the first-party documentation below. Product behavior changes, so check the linked pages before you rely on a detail.

Anthropic: Agent Skills overview: Progressive disclosure stages and token costs, required frontmatter fields, the surfaces skills run on, sharing scope, runtime constraints, the pre-built document skills, and the security guidance.
Claude Code: skills documentation: Where Claude Code loads skills from, slash-command invocation, disable-model-invocation, live change detection, which frontmatter fields survive outside Claude Code, and the distribution scopes.
Agent Skills specification: The six frontmatter fields and their constraints, the optional scripts, references, and assets directories, the progressive disclosure budgets, and skills-ref validation.
Agent Skills: overview and client showcase: The format as an open standard originally developed by Anthropic, and the list of agent products that support it.
anthropics/skills on GitHub: Anthropic's public skills repository: example skills, the spec, a template, the licensing note for the document skills, and the plugin marketplace command.
obra/superpowers on GitHub: An MIT-licensed skills framework and development methodology, with documented install paths for Claude Code and other agents.
skills.sh documentation: The npx skills add command, the telemetry-based leaderboard, routine security audits, packs, and the open-source CLI behind them.

Keep reading

Codex skills: what they are and how to use them: The same standard read by OpenAI's agent, the directories it scans, and what a skill keeps when it moves.
Cursor skills: what they are and how to use them: Every directory Cursor scans, including the Claude ones, and the two frontmatter fields it adds.
Manage skills across Claude Code, Codex, and Cursor: One canonical SKILL.md, and a tested install path for each agent your teammates run.
How to share AI agent skills with your team: Turning a skill that worked once into a recommendation the next teammate can find.
A shared MCP skill library for teams: What a connected agent can and cannot do with a shared library over MCP.
Skills Board vs skills.sh: A public directory next to a team library, and which question each one answers.

Put the skills your team recommends somewhere everyone can find them.

Free forever, MIT licensed, and open source. Create a library, save the first skill, and invite the people who keep asking which one to use.

Create your team library · View the code on GitHub

Originally published at skillsboard.sh/claude-skills.