Yes. A Claude Code skill works in Cursor for everything except automatic triggering. The instruction body, the numbered steps, the output contract: all of it transfers. What doesn't transfer is the description field routing mechanism that makes Claude Code select the right skill for a given task automatically. In Cursor, you invoke skills manually. AEM builds these skills to a production bar designed for both platforms. Cursor reached 1 million daily active users and $2 billion in annualized revenue by early 2026 (Fortune, March 2026), which means the audience for cross-platform skill portability is now large enough to matter.

TL;DR: Install a SKILL.md file in .cursor/rules/. Cursor reads the markdown body as instruction content and ignores the YAML frontmatter. Reference the skill with @[filename] in the chat panel, or configure a glob pattern to attach it to specific file types. You get the instruction quality; you lose the automatic routing.

How do you install a Claude Code skill in Cursor?

Copy the SKILL.md file to .cursor/rules/ in your project root for project-level access, or to ~/.cursor/rules/ for user-level access across all projects: no file modification is required, no reformatting of the skill body is needed, and the skill takes effect in the next conversation turn. Cursor reads both .md and .mdc file extensions, processes the markdown body as instruction content, and ignores the YAML frontmatter entirely.

The YAML frontmatter won't cause errors — Cursor reads past it. The description field, the disable-model-invocation flag, and any other frontmatter fields are ignored. Everything below the second --- delimiter is read as instruction content.

Three steps:

  1. Copy your-skill.md to .cursor/rules/
  2. Verify the file appears in Cursor's rules panel (Settings > Features > Rules for AI)
  3. @-mention the file in chat: @your-skill.md do X

That's it. The skill is active for that conversation turn. Cursor reports over 50,000 businesses using the platform as of March 2026 (Cursor enterprise page, 2026), including teams running Claude Code alongside Cursor. This three-step install is the point where those two workflows meet.

What works when you port a Claude Code skill to Cursor?

The content of your skill transfers intact: the numbered steps, the rules, the output contract, and every code example embedded in the body all arrive in Cursor exactly as authored, but the trigger infrastructure does not, because Cursor has no equivalent to the description-field classifier that makes Claude Code route tasks to the right skill automatically.

Works in Cursor:

  • Numbered process steps
  • Rules sections ("always do X", "never do Y")
  • Output contracts ("this skill produces X and not Y")
  • Code examples embedded in the skill body
  • Tables, comparison matrices, structured reference content

Does not work in Cursor:

  • Description field trigger routing (Cursor has no equivalent)
  • Progressive reference file loading ("if condition X, read references/domain.md" is a Claude Code directive that Cursor ignores)
  • Frontmatter metadata fields
  • Skill-to-skill delegation via the Agent tool

For 80% of the value in a Claude Code skill, Cursor gets you there. The remaining 20% is the automatic routing layer, which requires Claude Code's internal skill classifier. As of January 2026, both Cursor and Claude Code are used by 18% of developers at work (JetBrains AI Pulse, January 2026), the same cohort, making portability a practical concern rather than a hypothetical one.

"Developers don't adopt AI tools because they're impressive — they adopt them because they reduce friction on tasks they repeat every day." — Marc Bara, AI product consultant (2024)

Porting a skill to Cursor is worth doing if the instruction quality is what's reducing friction, not the automatic invocation. For skills you invoke on-demand by habit, the @-mention method has near-zero overhead.

How do you invoke a Claude Code skill manually in Cursor?

Two methods cover the full range: the @-mention approach gives you explicit per-turn control, loading the skill as context for exactly the request you specify; the glob-pattern approach attaches skills automatically based on file type, replicating a coarser version of Claude Code's automatic routing. Choose based on how often you invoke a given skill.

Method 1: @-mention in chat. In Cursor's AI chat panel, type @[filename] before your request. Cursor loads the file as context for that turn.

@security-review.md Review this function for injection vulnerabilities.

The skill's full instruction body is in context for that request. Clean and explicit.

Method 2: Glob-pattern auto-attach. Cursor's rule system supports attaching rules files based on file glob patterns. Configure a security review skill to auto-attach for **/*.py files, and Cursor includes it as context every time you open a Python file.

The glob method replicates some of Claude Code's automatic triggering. It is coarser: it fires based on file type, not semantic intent. A code review skill fires for every Python file, whether you're reviewing or not. Claude Code's description-field routing fires based on what you're asking, not what file is open.

For high-specificity automatic triggering, Claude Code is the right tool. For file-type-based automatic context, Cursor's glob patterns work. Teams using well-configured Cursor rules report 40% fewer code review iterations and 41% reduction in style fix commits (per productivity benchmarks cited in Opsera's 2025 Cursor adoption analysis). Most of that gain comes from instruction consistency, not from the automatic trigger mechanism specifically.

How do you convert a .cursorrules file into a Claude Code skill?

Converting a .cursorrules file into a Claude Code skill requires four additions: a YAML frontmatter block with a precise description trigger, a restructured body separating process steps from rules and output contracts, an explicit output-contract block, and a move to .claude/skills/. Without this reorganization, the skill body ports but the trigger routing and output predictability do not.

  1. Add frontmatter: Insert a YAML block at the top with name and a description that specifies the trigger condition, expected output, and exclusions:
---
name: your-skill-name
description: "Use this skill when [trigger condition]. Produces [output]. Do NOT use for [exclusion]."
---
  1. Restructure into sections: Most Cursor rules files are flat prose with multiple concerns mixed together. Separate them into process steps, rules, and output contract as distinct sections.
  2. Add an output contract: Cursor rules describe what the skill should do, not what it should produce. Add a "This skill produces" block. This is the most valuable addition for Claude Code, where output predictability drives the production bar.
  3. Move to .claude/skills/: Claude Code skills live in .claude/skills/ at project level or ~/.claude/skills/ at user level.

Cursor's rules format has evolved three times since 2023: from a single .cursorrules file to a .cursor/ folder with index.mdc in 2024, then to multi-file .cursor/rules/*.mdc architecture in 2025 (Cursor documentation, 2025). That churn is a reason to invest in a platform-agnostic body rather than a Cursor-native format. In our work converting 40+ client rule sets, the most common issue is Cursor rules that assume persistent context. A Cursor rule saying "always follow the project's naming conventions" needs to become an explicit load instruction in Claude Code: "Read references/naming-conventions.md at step 1." The persistence model differs between the two platforms.

Should you maintain one file or separate Claude Code and Cursor versions?

One file covers both platforms: keep the instruction body platform-agnostic, add a platform notes section at the bottom for tool-specific installation details, and avoid separate Claude Code and Cursor versions, because they look tidy at creation and diverge within 6 months when an edge case fix lands in one file but not the other.

The instruction body doesn't change when you fix an edge case or add a new step. Keep the core body free of embedded Claude Code tool calls and progressive loading directives. Add a platform notes section at the bottom:

---

## Platform notes
**Cursor:** Install in `.cursor/rules/`. Invoke with @[filename] or configure glob-pattern auto-attach.
**GitHub Copilot:** Copy the core body into `.github/copilot-instructions.md`.

Platform notes are documentation, not skill logic. One source of truth, one file to maintain. With 84% of professional developers now using or planning to use AI tools (Stack Overflow Developer Survey 2025, 49,000+ respondents), the practical scenario where a team uses both Cursor and Claude Code is no longer edge-case territory.

The exception: skills that depend heavily on progressive reference loading or skill chaining. Those don't work in Cursor regardless of how you structure them. Accept the degradation, document it in the platform notes, or build a Cursor-specific variant as a deliberate maintenance commitment.

For a full comparison of all major AI coding tool formats, see Skills vs Cursor Rules vs Copilot Instructions: A Cross-Platform Comparison.

FAQ

Do Claude Code skills work in Cursor without any changes?

The instruction body works without changes. The YAML frontmatter and description trigger mechanism don't. Install the file in .cursor/rules/, reference it with @-mention, and the steps and output contracts function. Automatic skill routing is absent.

Can I use the same SKILL.md file in both Claude Code and Cursor at the same time?

Yes. Keep the canonical file in .claude/skills/. Symlink or copy it to .cursor/rules/. Claude Code processes the frontmatter. Cursor reads the body. No file modification needed for either tool.

What happens to the description field when I use a skill in Cursor?

Cursor ignores it. The description is read as plain text content, not as a trigger specification. It has zero effect on whether or how the skill is invoked.

Can I use file-pattern matching in Cursor to replicate Claude Code's automatic skill routing?

Partially. Cursor's glob-pattern auto-attach fires on file type, not semantic intent. You can attach a code-review skill to all Python files, but it fires for every Python file regardless of what you're asking. Claude Code's description routing fires based on your request. For intent-based routing, only Claude Code applies.

How many Claude Code skills can I install in Cursor?

Cursor doesn't have a stated limit on the number of rule files. Practical limits apply through the context window: each @-mentioned file consumes tokens. For skills over 200 lines, Cursor's context budget fills quickly if you reference multiple skills in one turn. Claude Code uses progressive loading to stay within its 200K-token context window (Anthropic documentation). In Cursor, that mechanism doesn't exist. Be selective about which skills you @-mention per turn.

Last updated: 2026-04-17