Skills vs Cursor Rules vs Copilot Instructions: A Cross-Platform Comparison

If you've already built a Claude Code skill and wonder whether you can drop it into Cursor or GitHub Copilot, the short answer is: partially. The SKILL.md format was designed with portability in mind, and the core instruction body transfers across platforms with almost no changes. What breaks is the trigger mechanism. Each platform discovers and activates skills differently, and the description field that makes a Claude Code skill fire reliably does nothing in Cursor. This guide draws on Agent Engineer Master (AEM)'s experience converting 40+ client rule files and building production skills across platforms. 80% of developers now use AI coding tools in their daily workflows (Stack Overflow Developer Survey, 2025), and the choice of format determines what works across which tools.

TL;DR: SKILL.md files work across 14+ AI coding tools, but three elements require platform-specific handling: YAML frontmatter, the description field trigger mechanism, and Claude Code-specific tool calls embedded in steps. The instruction body, process steps, output contracts, and rules sections transfer cleanly to Cursor, GitHub Copilot, and Gemini CLI.

How do SKILL.md, .cursorrules, and copilot-instructions.md actually differ?

The three formats differ on scope control: SKILL.md uses a YAML description field for automatic per-task skill selection; .cursorrules applies instructions when you manually @-mention a file or configure glob patterns; copilot-instructions.md is always-on persistent context with no per-skill selection at all. The trigger architecture is the defining difference.

SKILL.md (Claude Code) is a structured file with YAML frontmatter and a description field that controls automatic triggering. Claude reads all skill descriptions at session startup and routes incoming requests to the right skill. A skill with no description is a skill that never fires automatically. The file supports progressive loading: reference files are pulled into context only when needed, not at startup.

Cursor rules (.cursorrules in older projects, .cursor/rules/*.mdc in newer ones) are markdown files without structured frontmatter. There is no automatic trigger mechanism. Cursor applies rules when you @-mention a file or configure glob-pattern matching. The rule content is instruction prose, similar to a SKILL.md body but without the trigger infrastructure.

GitHub Copilot instructions (.github/copilot-instructions.md) are simpler still: one file, no sections, no frontmatter. Copilot reads this file as persistent context applied to every interaction in the repository. There is no per-skill selection. Everything in the file is always active.

The structural difference is about scope control. Claude Code lets you build a library of dozens of skills and activate only the relevant one per task. Copilot gives you one persistent instruction block. Cursor sits in between, with rule files you can include selectively. As of April 2026, 18% of developers use both Claude Code and Cursor at work, with GitHub Copilot still holding 42% of the paid AI coding tools market (JetBrains Developer Ecosystem Survey, 2026).

The table above has one important implication: skills that rely on Claude Code-specific features (progressive reference loading, multi-skill routing, frontmatter controls) degrade predictably on other platforms. Skills with clean, self-contained instruction bodies transfer without degradation.

Which AI coding tools support SKILL.md files in 2026?

As of 2026, 14+ AI coding tools support SKILL.md files, but support divides into two tiers: native support in Claude Code means full description-field routing, progressive reference loading, and YAML frontmatter processing, while every other compatible tool reads the instruction body as a plain context file and ignores the trigger infrastructure entirely. The remaining tools offer compatibility support, reading the instruction body without processing frontmatter.

Native support means the platform reads YAML frontmatter, processes the description field for trigger classification, and loads skill content progressively. Fewer than 5 platforms implement the full feature set as of 2026. 85% of developers use AI coding tools regularly, and 62% rely on at least one AI coding assistant, agent, or code editor (JetBrains, State of Developer Ecosystem, 2025).

Compatibility support means the platform reads the SKILL.md body as a context file without processing frontmatter. The instruction quality comes through. The trigger infrastructure is invisible to the platform.

For practical purposes: if you install a SKILL.md file in a compatibility-mode platform, your instructions work but you need to invoke the skill manually. The description directive, the character budget controls, the disable-model-invocation flag: all ignored.

The SkillsMP marketplace tags each skill with its compatibility profile, so you can see before downloading whether a skill uses Claude Code-specific features. The AI coding tools market reached $7.37 billion in 2025, with Gartner projecting 90% of enterprise software engineers will use AI coding assistants by 2028 (Gartner, 2025).

What features are Claude Code-specific and won't port to other platforms?

Four elements are Claude Code-only and do not transfer to other platforms, because each one depends on capabilities built into Claude Code's internal architecture that no other tool in the 14+ compatible set has replicated; the numbered list below identifies them so you know exactly what to strip before deploying a skill elsewhere. Strip these four features and every other part of the SKILL.md file transfers cleanly to Cursor, Copilot, and Gemini CLI without modification.

1. Description field trigger mechanism: The description drives automatic skill selection. Claude reads it at startup and classifies incoming requests against it. A description like "Use this skill when the user asks to review code for security vulnerabilities. Do NOT invoke for general code questions" is semantically parsed and used for routing. Cursor and Copilot have no equivalent parser.

2. YAML frontmatter metadata: The disable-model-invocation flag, character budget controls, and Claude Code-internal metadata fields are processed only in Claude Code. Other platforms read these lines as text or skip them.

3. Progressive reference file loading: Claude Code loads reference files on demand when the skill body instructs it to: "If the task involves database queries, read references/sql-patterns.md." This is a Claude Code-specific execution pattern. Other platforms load all context upfront or require explicit file attachments in the chat.

4. Skill-to-skill delegation syntax: The Agent tool pattern, where one skill invokes another, is Claude Code-only. Cursor and Copilot don't support programmatic skill chaining.

Everything else transfers. If you keep your instruction bodies clean, the quality of the skill comes through on any platform:

• Numbered process steps
• Rules sections
• Output contracts
• Code examples
• Comparison tables
• Reference file paths

Each skill uses approximately 100 tokens during metadata scanning at startup; when activated, the full skill content loads at under 5,000 tokens (Anthropic, Claude Code Docs, 2025).

"The failure mode isn't that the model is bad at the task — it's that the task wasn't specified tightly enough. Almost every production failure traces back to an ambiguous instruction." — Simon Willison, creator of Datasette and llm CLI (2024)

This is true regardless of platform. A tightly specified instruction body works in Claude Code, Cursor, and Copilot. The platform changes the delivery mechanism, not the quality bar.

For more on how to write instruction bodies that hold up across all platforms, see What Goes in a SKILL.md File?.

How do I convert a Cursor rules file into a SKILL.md?

Converting a .cursorrules file to SKILL.md requires four structural additions that do not exist in Cursor's flat prose format, and the instruction prose transfers unchanged through all four steps because the additions wrap the existing content rather than replacing it. The scaffolding changes; the instruction quality you already wrote does not.

1. Add YAML frontmatter: Wrap the file with --- delimiters and add the minimum required fields:

---
name: your-skill-name
description: "Use this skill when [trigger condition]. Produces [output format]. Do NOT use for [exclusion]."
---

The description is the most important addition. Write it as a directive, not a label. "Code reviewer" is a label. "Use this skill when the user asks for a security review of code. Produce a structured risk list. Do NOT use for formatting or style feedback" is a directive.

2. Reorganize content into explicit sections: Cursor rules are flat prose. Restructure into labeled sections:

## Process steps
1. Read the target file
2. Identify security risks...

## Rules
- Always flag hardcoded credentials
- Never suggest removing error handling

## This skill produces:
- A structured list of security risks...

3. Add an output contract: Most Cursor rules files define what the skill should do but not what it should produce. Add a "This skill produces" section and a "This skill does NOT produce" section. This constraint is the most valuable addition: it eliminates the output variance that makes skills unreliable across different context windows.

4. Move the file to .claude/skills/: Cursor rules live in .cursor/rules/ or the project root. Claude Code skills live in .claude/skills/ (project-level) or ~/.claude/skills/ (user-level). Move the file to the correct location.

In our experience converting 40+ client rule files through this process, the most common issue is Cursor rules that assume persistent context ("always apply the project's error-handling conventions") when they need to become explicit load instructions in Claude Code ("read references/error-conventions.md at step 1"). The persistence models are different. An empirical study of developer-provided context files found that most projects describe the technology stack and configuration steps as the core context content, with output format specifications added in under a third of cases (arXiv, 2512.18925, 2025). The output contract is the most commonly missing element.

For the full step-by-step guide, see How Do I Convert a Cursor Rules File Into a Claude Code Skill?.

How do I write a skill that works in both Claude Code and Gemini CLI?

Write the skill for Claude Code first, then verify the instruction body is platform-agnostic before deploying to Gemini CLI, which means checking that none of the three Claude Code-specific elements appear in the steps: frontmatter directives, progressive loading instructions, or tool call syntax. The resulting body runs correctly in Gemini as always-on project context. The core challenge is that Claude Code triggers skills via the description field, while Gemini CLI loads all project context into every conversation.

You cannot replicate Claude Code's selective triggering in Gemini, but you can write instruction bodies that behave correctly whether triggered selectively or applied as always-on context. Gemini CLI uses GEMINI.md as its project context file, loaded hierarchically from the user home directory through all parent directories (Google, Gemini CLI Docs, 2025). The format is plain markdown, no frontmatter required.

Three rules for portable instruction bodies:

1. No platform-specific tool calls embedded in steps: "Use the Read tool to load the configuration file" is Claude Code-only. "Read the configuration file" works everywhere. Write tool-agnostic steps where possible.

2. No progressive reference loading instructions: The pattern "If the task involves database queries, read references/sql-patterns.md" is a Claude Code execution directive. Other platforms ignore it. For cross-platform skills, either inline the reference content or accept that the loading step will be skipped on non-native platforms.

3. Keep the output contract explicit: Every platform respects a clear output specification. "Produce a JSON object with these three fields: risk_level, description, and remediation" works on every platform. "Produce something useful" does not.

In our builds targeting multiple platforms, the platform-agnostic framing adds 10-15 lines per skill. The functional quality stays the same. The description field is the one element that gets replaced with a platform-specific activation method. 60% of developers surveyed report that AI coding assistants "miss relevant context," making the context file structure the most requested improvement area (Second Talent, AI Coding Assistant Statistics, 2025).

A wit: most prompt files are a prompt in a trenchcoat. A well-built SKILL.md is the only format that ships with a badge.

Should I maintain one cross-platform file or platform-specific variants?

Maintain one file with a clearly marked platform notes section at the bottom: the instruction core does not change between platforms, only the delivery metadata changes, and that belongs in a documented notes section appended to the single source file. Platform variants sound reasonable until you have six copies of the same skill and three are six months out of date.

The structure that works:

---
# Claude Code frontmatter + description here
---

[Core instruction body — platform-agnostic steps, rules, output contract]

---

## Platform notes
**Cursor:** Install in `.cursor/rules/`. Invoke with @[filename] in the chat panel,
or configure a glob pattern to auto-attach for relevant file types.

**GitHub Copilot:** Copy the core instruction body (without frontmatter) into
`.github/copilot-instructions.md`. The output contract and rules sections transfer directly.

**Gemini CLI:** Place in `.gemini/styleguide.md` or reference from project context.

The platform notes section is documentation, not skill logic. The instruction body doesn't change between platforms. One file, one source of truth.

The exception: skills that use Claude Code-specific features heavily. If your skill depends on progressive reference file loading or skill-to-skill delegation, a Cursor variant needs a rewrite, not a note. But that's a skill design decision, not a maintenance decision. Build those features only when you're committed to Claude Code as the primary platform. Claude Code has become the most-loved AI coding tool at 46% satisfaction, ahead of Cursor at 19% and GitHub Copilot at 9% (JetBrains, Which AI Coding Tools Do Developers Actually Use at Work, April 2026).

How does skill discovery differ across platforms, and how does that affect description writing?

Skill discovery works differently on each platform: Claude Code reads all skill descriptions at startup and routes requests semantically; Cursor requires a manual @-mention or glob pattern match; GitHub Copilot has no discovery at all, applying one instructions file to every interaction; Gemini CLI loads all project context files into every conversation. Each model means a different description strategy.

In Claude Code, the description field is the routing mechanism. Imperative descriptions ("Use this skill when...") achieve a 100% activation rate in AEM internal testing. Passive descriptions ("This skill handles...") sit at 77% (AEM internal testing, 650 trials). The gap is caused by the classification algorithm favoring directive language.

In Cursor, skill discovery is manual. You @-mention a rules file or configure file-pattern matching. Descriptions are documentation, not triggers.

In GitHub Copilot, there is no discovery mechanism. One instructions file, always active.

In Gemini CLI, project context files are loaded into every conversation. No per-skill selection.

The practical implication: write descriptions for Claude Code first, as directives. A well-formed directive description also reads well as documentation on other platforms. "Use this skill when the user asks to review an API for security vulnerabilities" is useful to a developer reading the file in any context.

The description optimization work you do for Claude Code is free documentation value everywhere else. Zero redundant effort. Research on skill description optimization shows that adding trigger examples to a description can improve activation from 72% to 90%, compared to descriptions without examples (Anthropic, Claude Code Skills Guide, 2025).

For a deeper look at how the description field controls Claude Code triggering, see The SKILL.md Description Field: The One Line That Makes or Breaks Your Skill.

What is the competitive landscape for AI skill formats, and will one standard win?

SKILL.md has the broadest adoption as of 2026, with 14+ platforms supporting it, but adoption breadth and implementation depth are different things: fewer than 5 of those platforms implement the full four-feature set, which means the standard is won at the surface level and contested at the implementation level. In December 2025, Anthropic released the Agent Skills specification as an open standard and OpenAI adopted the same format for Codex CLI (Anthropic, 2025).

The honest assessment: a universal format converges toward the lowest common denominator. The four features that distinguish SKILL.md in Claude Code (description-driven routing, progressive reference loading, frontmatter controls, and skill-to-skill delegation) are Claude Code-specific because they depend on Claude Code's internal architecture. Fewer than 5 of the 14+ supporting platforms replicate all four.

The practical answer for most developers: build primary skills for Claude Code. Keep instruction bodies platform-agnostic. Accept that on other platforms you lose automatic triggering and progressive loading. You keep 80% of the functional value. Claude Code went from 3% developer adoption in April 2025 to 18% in January 2026, a 6x increase in nine months (JetBrains, April 2026). Cursor crossed $2 billion in annualized revenue by February 2026 with over 1 million daily active users (Cursor, 2026).

For teams that need full multi-platform parity, a build-step approach works: canonical SKILL.md as the source, a generator that produces platform-specific outputs (stripped .mdc for Cursor, extracted body for Copilot). That is infrastructure, not skill design. Most solo developers don't need it.

The format competition will not be won by whoever has the most platforms. It will be won by whoever has the deepest implementation on the platform developers use most. As of 2026, that implementation is Claude Code. GitHub Copilot has 20 million all-time users and 4.7 million paid subscribers as of January 2026 (GitHub/Microsoft, 2026), but the deepest skill architecture belongs to Claude Code.

For the specific compatibility details by platform, see What AI Coding Tools Support SKILL.md Files? and Can I Use the Same Skill File Across Different AI Assistants?.

FAQ

Can I use a SKILL.md file in Cursor?

Yes. Install it in .cursor/rules/ and invoke with @[filename] in the chat panel. Cursor reads the markdown body as instruction content. The YAML frontmatter and description field are ignored for triggering. You get the instruction quality without the automatic routing.

Do Claude Code skills work in GitHub Copilot?

Not natively. Copilot uses a single .github/copilot-instructions.md file and has no per-skill routing. To use a Claude Code skill in Copilot, copy the instruction body (without the frontmatter) into the Copilot instructions file. The output contracts and rules transfer. Automatic skill selection does not.

How do I migrate my Cursor rules to Claude Code skills?

Add YAML frontmatter with a name and description field. Reorganize the content into explicit sections (process steps, rules, output contract). Move the file to .claude/skills/. The instruction body transfers unchanged. Writing the description is new work: it should be a directive that tells Claude when and why to invoke the skill.

Can I use skills from SkillsMP in Cursor or only in Claude Code?

SkillsMP skills include compatibility tags. Skills tagged "Claude Code only" use features that don't port. Skills tagged "Universal" can be dropped into Cursor or Copilot with minor modifications. Check the compatibility tag before building a workflow dependency on any skill.

Do Claude Code skills work in JetBrains IDEs?

JetBrains AI Assistant supports SKILL.md files in compatibility mode: it reads the instruction body but ignores the frontmatter and trigger mechanism. Install the skill, invoke it manually via the AI chat, and the steps and output contracts function as intended.

Which AI coding assistant has the best skills implementation in 2026?

Claude Code has the most complete implementation because SKILL.md was built for it. Semantic routing, progressive loading, and frontmatter controls only work natively in Claude Code. If you need automatic skill selection based on task intent, there is no platform-level substitute for Claude Code's description field routing.

Is the universal SKILL.md format truly universal?

Universal by adoption, not by feature parity. 14+ platforms read SKILL.md files. Fewer than 5 implement the full feature set. The instruction body is universal. The Claude Code-specific features are not. If your skill uses only platform-agnostic instructions, it ports cleanly everywhere.

Last updated: 2026-04-17