Claude Code Skills vs Cursor Rules vs Codex Skills

Claude Code, Cursor, and Codex all let you customize how the AI behaves in your projects. But they approach it differently. Claude Code uses SKILL.md skills, Cursor uses .cursorrules files, and Codex uses its own skills system based on the same SKILL.md open standard. Here's how they compare.

The basics

All three systems solve the same problem: giving the AI context and instructions specific to your project, your team, or your workflow. Without customization, every AI coding tool defaults to generic behavior. With it, you get output that matches your conventions.

Claude Code skills are folders containing a SKILL.md file with YAML frontmatter and markdown instructions. They can also include scripts, reference docs, and assets. Skills are discovered automatically by the agent and can be invoked manually with slash commands.

Cursor rules are .cursorrules files placed in your project root. They contain plain text instructions that Cursor loads into context for every interaction. Simpler than skills but less structured.

Codex skills use the same SKILL.md format as Claude Code (they share the open Agent Skills standard). Codex added an openai.yaml file for UI metadata and MCP tool dependencies. Installation uses a CLI installer.

Format comparison

Claude Code and Codex skills use the same file format: a SKILL.md with YAML frontmatter (name, description) and markdown instructions. In most cases, a skill written for one works with the other without modification.

Cursor rules are simpler. A .cursorrules file is just a text file with instructions. No frontmatter, no folder structure, no supporting files. You write what you want Cursor to do, and it loads those instructions into every conversation.

The tradeoff is flexibility vs. simplicity. Cursor rules are faster to set up. SKILL.md skills are more powerful because they support automatic discovery (the agent decides when to load them), multiple skills per project, supporting scripts, and reference files.

Portability

This is where the biggest difference shows up.

SKILL.md is an open standard. Skills written in this format work across Claude Code, Codex, Gemini CLI, and other tools adopting the standard. Write once, use across agents. Some agent-specific features (like Claude Code's subagent context forking) may not translate, but the core instructions work everywhere.

Cursor rules are Cursor-only. They work great inside Cursor, but if you switch to Claude Code or Codex, you'd need to manually convert them into SKILL.md format.

For teams that use multiple tools or might switch tools in the future, the SKILL.md format is the safer bet. For developers committed to Cursor, .cursorrules gets the job done with less setup.

Discovery and invocation

Claude Code: Skills are discovered automatically. The agent reads skill descriptions at session start and loads the relevant skill when your request matches. You can also invoke manually with /skill-name. Skills can be set to manual-only with disable-model-invocation: true.

Cursor: Rules are always loaded. There's no discovery mechanism because .cursorrules applies to every interaction in the project. This is simpler but means you can't have task-specific rules that only activate when relevant.

Codex: Similar to Claude Code. Skills are discovered via description matching and loaded on demand. Codex uses progressive disclosure, loading only metadata at start and full instructions when needed.

Ecosystem and marketplace

Claude Code has the largest skill ecosystem. The official Anthropic marketplace, multiple community marketplaces on GitHub, and curated marketplaces like Agensi where skills are security-reviewed and rated. Thousands of skills are available.

Cursor has a growing community sharing .cursorrules files on GitHub and in forums, but there's no official marketplace or discovery mechanism. You find rules by searching GitHub or asking in communities.

Codex has an official skills catalog on GitHub with around 35 curated skills. The catalog is well-organized but small compared to the Claude Code ecosystem. No marketplace UI, no ratings, no visual browsing.

Team collaboration

All three approaches support team sharing through version control.

Claude Code: Put skills in .claude/skills/ in your repo. Every developer who clones it gets the skills automatically. Organizations can also provision skills centrally for all users.

Cursor: Put .cursorrules in your repo root. Everyone on the team gets the same rules when they open the project in Cursor.

Codex: Put skills in .codex/skills/ or use the CLI installer. Similar to Claude Code's approach.

Which should you use?

If you use Claude Code primarily: Use SKILL.md skills. You get automatic discovery, the largest ecosystem, and portability to other agents if you switch later. Browse skills on Agensi or create your own.

If you use Cursor primarily: Start with .cursorrules for project conventions. For more complex, reusable workflows, consider writing SKILL.md skills and placing them in a skills directory. Cursor may add native SKILL.md support in the future as the standard grows.

If you use Codex primarily: Use SKILL.md skills. The format is the same, and skills from the Claude Code ecosystem often work with minimal or no changes.

If you use multiple tools: Standardize on SKILL.md. It's the only format that works across all major agents. You can always convert a SKILL.md into a .cursorrules file, but not the other way around without losing structure.

For more on the SKILL.md format, read our complete guide.