# Claude Code Skills vs Cursor Rules vs Codex Skills

> Three on-demand instruction formats, three different load triggers: Claude Code's SKILL.md, Cursor's .cursorrules/.mdc, and Codex's native skills. What each file looks like, how portable it is, and which one to standardize on if you run more than one tool.

Canonical: https://www.agentickit.co/compare/claude-code-skills-vs-cursor-rules-vs-codex-skills
Last updated: 2026-11-18

Claude Code skills (.claude/skills/<name>/SKILL.md) load on demand when a task matches their description. Cursor rules (.cursor/rules/*.mdc, or the legacy .cursorrules) load either always-on or by glob/manual trigger, which makes them a different primitive than a skill even though people compare them head to head. Codex's native skills sit closer to Claude Code's model — on-demand, description-gated — but live in their own folder and frontmatter shape. If you're standardizing one repo across tools, know which of these three you're actually choosing between before you pick a format. Last updated 2026-10-31 by Rakshit Yadav.



## Verdict in one line
**These three aren't quite the same primitive, which is why comparing them is confusing in the first place.** A Claude Code skill and a Codex skill are both on-demand files, gated by a description, that stay out of context until a task matches. A Cursor rule is usually something closer to always-on project memory (or a glob-triggered file-type rule) — the nearest Cursor equivalent to an on-demand skill is a Cursor *skill* file (a newer, less universally supported addition), not a rule. If your actual question is "on-demand playbook vs always-loaded memory," that's a different comparison — see [Cursor Rules vs Skills vs Commands](https://www.agentickit.co/compare/cursor-rules-vs-skills). This page is for solo founders who run more than one of Claude Code, Cursor, and Codex on the same repo and need to know what moves and what doesn't.

## Format differences, side by side
<table><thead><tr><th></th><th>Claude Code skill</th><th>Cursor rule</th><th>Codex skill</th></tr></thead><tbody><tr><td>**File**</td><td>`.claude/skills/&lt;name&gt;/SKILL.md`</td><td>`.cursor/rules/*.mdc` (legacy: single `.cursorrules` at repo root)</td><td>Codex-native skill file, discovered from the project's skills directory</td></tr><tr><td>**Load trigger**</td><td>On demand — the agent's own judgment matches the `description` field, or a command/subagent names it directly</td><td>Depends on the rule's declared type: `always` (every turn, no gating), glob-matched to a file pattern, or manually invoked</td><td>On demand — description-gated, closer to Claude Code's model than to a Cursor rule</td></tr><tr><td>**Frontmatter**</td><td>YAML: `name`, `description`</td><td>YAML: rule type plus optional glob pattern; no description-based matching for `always` rules since those load unconditionally</td><td>Metadata block identifying the skill and when it applies; exact fields are still settling as the format is newer</td></tr><tr><td>**Body**</td><td>Plain markdown, any length, since it's free until opened</td><td>Markdown or plain text; kept short in practice because `always` rules cost context on every single turn</td><td>Plain markdown playbook, similar shape to a Claude Code skill body</td></tr></tbody></table>The practical trap: a Cursor `.cursorrules` file is not a drop-in substitute for a Claude Code SKILL.md. A rule set to `always` behaves like CLAUDE.md, not like a skill — see [Cursor Rules vs AGENTS.md vs CLAUDE.md](https://www.agentickit.co/compare/cursor-rules-vs-agents-md-vs-claude-md) for that specific pairing.

## Portability across all three tools
The markdown *body* of an instructional file — the actual playbook, checklist, or gotcha list — rarely references the tool it runs in, so that part copies across all three with no edits. What breaks on a straight copy is everything around the body: Claude Code's skill lives inside a named folder with its own frontmatter and can be addressed by name from a subagent or command; a Cursor rule has no equivalent on/off-demand gating unless you specifically give it a glob, and an `always` rule dumped verbatim into a skill folder on another tool will load fine but was written assuming it's paid on every turn, so it's often padded with reminders a true on-demand skill doesn't need. Codex's skill format is the newest of the three and still has the least tooling around bulk conversion, so moving a Codex skill to Claude Code or Cursor today is mostly manual: copy the body, rebuild the frontmatter by hand. None of the three formats require touching the body text itself if it's pure instructional content with no tool-specific command or subagent references baked in.

## Which format wins for a solo founder standardizing one repo
If you have to pick one format to treat as the source of truth and generate the others from it, pick Claude Code's SKILL.md. Three reasons: it has the clearest on-demand semantics of the three (no ambiguity about whether it's always-loaded like a Cursor `always` rule), it can be addressed by name from both commands and subagents rather than relying only on the main loop's judgment, and the [Claude Code skills ecosystem](https://www.agentickit.co/skills) already has the most tooling built around it, including conversion helpers. Keep a thin Cursor `.mdc` shell pointing at the same body if you also run Cursor day to day, and treat any Codex skill as a manual port for now rather than something you maintain three-ways in lockstep — the format is too new for round-trip tooling to be worth building yet. The one thing not to do: write a Cursor rule as `always` just because that's the default, then expect it to behave like an on-demand skill when you eventually move it — decide the loading behavior you actually want first, independent of which tool you're copying from.

## AgenticKit's config-converter for migrating between formats
The mechanical parts of this — folder structure, frontmatter field names, path rewriting — are what the [Config Converter](https://www.agentickit.co/tools/config-converter) handles when moving a Claude Code skill to a Cursor rule or back. It won't decide for you whether a given file should load always-on or on-demand once it lands in the other tool; that call depends on what the content actually is, and is worth making deliberately rather than inheriting from whichever tool you wrote it in first. Anything with a reference to a specific subagent file under `.claude/agents/` needs a human pass after conversion, since neither Cursor rules nor Codex skills have a matching concept to point at.



## FAQ

### Is a Cursor rule the same thing as a Claude Code skill?
Not exactly. A Claude Code skill is always on-demand, gated by its description. A Cursor rule can be always-on, glob-matched, or manually invoked — only the manual/glob-matched variants behave like an on-demand skill. An always rule behaves more like CLAUDE.md than like SKILL.md.

### How does a Codex skill differ from a Claude Code skill?
Both are on-demand, description-gated files, so the loading model is close. They differ in file location, exact frontmatter fields, and — since the Codex format is newer — in how much conversion tooling exists for moving one to another tool today.

### Can I use one SKILL.md body across Claude Code, Cursor, and Codex?
The instructional body usually copies unchanged if it contains no tool-specific command or subagent references. The frontmatter and folder structure differ per tool, so you'll maintain three thin shells pointing at the same content rather than one literal file in three places.

### Which format should I pick if I'm standardizing on one tool?
Claude Code's SKILL.md, for a solo founder running more than one tool on the same repo: it has the clearest on-demand semantics, can be addressed by name from commands and subagents, and has the most existing tooling, including format conversion.

### Does AgenticKit support Codex?
AgenticKit's primary install targets Claude Code, with Cursor supported as a secondary ecosystem. There is no dedicated Codex skill generator today; a Codex skill is best hand-ported from a Claude Code SKILL.md body using the same format-conversion logic as the Cursor side.

## Related
- [Skills pillar](https://www.agentickit.co/skills)
- [Cursor Skills vs Claude Code Skills](https://www.agentickit.co/compare/cursor-skills-vs-claude-skills)
- [Cursor Rules vs Skills vs Commands](https://www.agentickit.co/compare/cursor-rules-vs-skills)
- [Cursor Rules vs AGENTS.md vs CLAUDE.md](https://www.agentickit.co/compare/cursor-rules-vs-agents-md-vs-claude-md)
- [CLAUDE.md vs Skills vs Subagents vs Hooks](https://www.agentickit.co/compare/claude-code-skills-vs-subagents-vs-hooks)
- [Config Converter](https://www.agentickit.co/tools/config-converter)
