Claude Skills vs Agent Skills vs Cursor Rules: What’s the Difference? (2026)

1. Why Claude Skills, Agent Skills, and Cursor Rules keep getting mixed up

From late 2025 through 2026, AI coding tools converged on the same idea: versionable Agent configuration checked into the repo. Cursor strengthened .cursor/rules and .cursor/skills. Anthropic promoted .claude/skills inside Claude Code. The community pushed agentskills.io as a cross-host standard. All three movements arrived within months of each other, marketing copy all used “Skill” and “Agent,” and translations in non-English communities were inconsistent. The result is a familiar set of confusions:

• Pasting a 30-step release procedure into Cursor Rules, so every conversation carries thousands of tokens whether or not anyone is shipping;
• Looking for a “Rules panel” inside Claude Code and discovering the product calls them Skills;
• Downloading someone’s shared SKILL.md and not knowing whether it belongs under .cursor or .claude;
• Assuming “Agent Skills” is a new SaaS product when it is actually a file-format specification.

The root cause is product layer, implementation layer, and standards layer sharing vocabulary. If you have already read our AI Coding Workflow, Rules, and Skills deep dive, treat that as the workflow architecture playbook. This article is the term-by-term glossary and decision manual—complementary, not redundant. Where the workflow article asks “how do I orchestrate Plan mode, slash commands, and CI?” this one asks “when someone says Claude Skills on Twitter, what file are they actually talking about?”

Naming collisions hurt more than semantics. When a team mislabels a runbook as a Rule, every engineer pays a latency and quality tax: the model has less room for the actual diff, and unrelated tasks inherit release steps that encourage hallucinated deploys. When someone treats Agent Skills as a Claude-only feature, they duplicate maintenance across Cursor and Claude Code instead of sharing one SKILL.md body. Getting the vocabulary right is the cheapest fix in AI-assisted development—and the one most teams skip because the words sound interchangeable.

Another driver is documentation fragmentation. Cursor’s docs speak in Rules and Skills. Anthropic’s docs say Claude Code Skills. agentskills.io speaks in neutral spec language. None of the three pages open with “here is how we relate to the other two,” so integrators fill the gap with blog posts and Discord threads. This guide is deliberately that missing map: same headings as our Chinese edition, same tables, same examples—so your team can point new hires to one canonical explainer.

2. What each one actually is (What)

2.1 Cursor Rules — the always-loaded constraint layer

Cursor Rules are resident policy inside the Cursor IDE: when you open a matching project, they are injected into context automatically. Common locations include project .cursor/rules/*.mdc, Rules in user Settings, and root AGENTS.md. They are the right home for: minimize diff, forbidden directories, reply language, when tests must run, never force-push, and other short, hard clauses that must hold on every turn. Official guidance stresses that Rules should stay lean—long runbooks do not belong here.

Rules are not “weak Skills.” They use a different loader, different file extension (.mdc with optional globs), and a different contract with the Agent: always on, no semantic matching required. That is powerful for governance and dangerous for procedural bulk. A good Rule fits on one screen; if you need step numbers and command blocks, you are holding a Skill.

2.2 Claude Skills — on-demand runbooks inside Claude Code

Claude Skills (Claude Code Skills) are capability packages inside Anthropic’s terminal/IDE Agent product. They live at .claude/skills/<name>/SKILL.md (or in a user-level skills directory). The Agent reads description in frontmatter first, matches user intent, then loads the body to execute multi-step flows such as code review, release, or security audit. You can invoke them explicitly with /skill-name, and you can set disable-model-invocation to prevent accidental triggers on sensitive procedures. For deeper design patterns, see our Claude Code Skills: 10-skill framework guide.

Claude Skills are a product feature name tied to Claude Code’s runtime: discovery, invocation, and optional safety flags. When Anthropic documentation says “Skills,” it means “how Claude Code loads and runs SKILL.md packages,” not “every SKILL.md on the internet.” That distinction matters the moment you copy a community Skill into your repo—you are importing both a format (Agent Skills) and a host behavior (Claude Skills).

2.3 Agent Skills — the cross-tool SKILL.md open standard

Agent Skills are not a feature toggle from any single vendor. They are the file format and directory conventions defined by the Agent Skills Specification: SKILL.md frontmatter (name, description, and related fields), a procedural body, and optional references/ or scripts. Hosts such as Cursor and Claude Code parse the same structure, so teams can keep one shared Skill body and sync it to .cursor/skills and .claude/skills, tweaking only host-specific frontmatter where docs require it. The standard solves portability; it does not replace Cursor Rules’ always-on constraints.

Think of Agent Skills as Markdown for runbooks: the spec does not run anything by itself. A host must implement discovery, description matching, and invocation. When two hosts both claim compatibility, compare their changelogs—optional fields and invocation semantics can diverge even when the on-disk file looks identical.

3. Core comparison table (How Compare)

3.1 Paths and ownership

When auditing a repo, start by separating filenames from roles. Seeing .mdc under .cursor/rules signals always-on Cursor policy. Seeing SKILL.md signals a runbook that should load only when relevant—regardless of whether the folder is named .cursor/skills or .claude/skills. Mixing extensions (dropping SKILL.md into rules/) is the most common reason “my Skill never triggers.”

4. How to choose by scenario (decision matrix)

The matrix is intentionally blunt: it names a default first move, not a forever ban on other tools. Dual-stack teams almost always end with one canonical Skill source plus host-specific constraint files. Trying to mirror every Cursor Rule verbatim into Claude’s world wastes effort—instead, share procedural knowledge (Skills) and keep environment-specific guardrails where each product reads them.

5. Recommended stacks (Stack)

Stack A — Cursor single stack (solo projects)

• Rules: core.mdc with three red lines (minimize diff, no commits unless asked, run lint after edits)
• Skills: one code-review package (Agent Skills format under .cursor/skills/)
• Skip Claude directories in the repo to avoid noise if nobody uses Claude Code

Stack B — Claude Code single stack (terminal-first)

• Claude Skills: commit, security-review (use disable-model-invocation: true on the latter)
• Root CLAUDE.md carries standing constraints—analogous to Rules, not part of Agent Skills

Stack C — dual-stack team (recommended at scale)

• Single skills/ source directory or git submodule; CI syncs into .cursor/skills and .claude/skills
• Cursor Rules only for Cursor developers; Claude users read CLAUDE.md
• Draft new Skills against the Agent Skills spec first, then apply per-host frontmatter tweaks

Stack D — Agents with remote execution

• Skill documents SSH steps to a cloud Mac for xcodebuild
• Rules forbid changing production config without explicit confirmation
• Pin a stable macOS image for execution—aligned with the “execution environment” dimension in our AI coding tool comparison

Stacks are not religions. A solo maintainer on Stack A can adopt Stack C the day a teammate installs Claude Code—without rewriting review logic, only adding a sync step. The expensive mistake is choosing Stack “whatever was in the last tweet” and dumping every snippet into Rules because that folder was already open in the tree view.

6. Common misconceptions

• “Agent Skills is Claude-only” → It is an open format; Claude Skills is one vendor implementation.
• “Cursor Rules can hold a 20-step release flow” → Split it into a Skill; long Rules waste context on every message.
• “Copy SKILL.md into the Rules folder and it works” → Different extension and loader; .mdc Rules do not semantic-match on Skill description.
• “The three terms are mutually exclusive” → Typical production setup is Rules (constraints) + Skills (procedures) + Agent Skills format (sharing).
• “Skills replace Rules” → Skills load on demand; they cannot enforce “never force-push” on every turn by themselves.
• “When the standard updates, Claude Skills auto-compat” → Watch agentskills.io and host changelogs; frontmatter fields can diverge.

Two subtler pitfalls deserve callouts. First, description spam: writing a Skill description so broad that it matches half the backlog (“use for any coding task”) recreates the Rule problem on a slower trigger. Second, shadow Rules: stuffing policy into CLAUDE.md or a mega AGENTS.md because it feels easier than learning .mdc globs—works until the file grows past auditability. Treat those project docs like Rules: short, enforceable, and reviewed in PRs.

7. Seven-step rollout with copy-paste examples

1. Inventory: List constraints that must hold on every conversation → Cursor Rule candidates. List occasional procedures → Skill candidates.
2. Write Rules: Keep each file under ~80 lines; use globs to scope when possible.
3. Draft SKILL.md per Agent Skills: name plus a verb-led description that states when to load.
4. Place in host directories: Cursor uses .cursor/skills/<name>/SKILL.md; Claude Code uses .claude/skills/.
5. High-risk Skills: Add disable-model-invocation: true; allow only explicit /security-review-style invocation.
6. Commit to Git: Ship config in the same PR as code so laptops are not the source of truth.
7. Bind macOS nodes: When a Skill mentions Xcode or shell on Mac, document SSH targets and preflight checks in the runbook body.

After rollout, run a tabletop exercise: ask a teammate to request a code review without naming your Skill. If the Agent loads the right file, your description is calibrated. If it edits blindly, tighten the description or require explicit /code-review. Repeat for a forbidden directory named in Rules—the Agent should refuse even when the user never mentions policy.

# .cursor/rules/core.mdc
---
description: Core repo constraints (always on)
globs: "**/*"
---
- Minimize diff; no drive-by refactors.
- Never commit unless the user explicitly asks.
- Do not modify backend/ unless the task requires it.

# .cursor/skills/code-review/SKILL.md  (Claude: .claude/skills/code-review/SKILL.md)
---
name: code-review
description: Review staged git diff for bugs and test gaps. Use when user asks for review or before PR.
---
1. Run `git diff --staged` (or branch vs main).
2. Report Critical / Warning / Suggestion.
3. Do not auto-fix unless asked.

---
name: xcode-release
description: Archive and export IPA on macOS runner. Manual invocation only.
disable-model-invocation: true
---
Prerequisites: macOS host, valid signing cert, Xcode selected.
Steps: clean → archive → export → verify IPA checksum.

8. Summary

Cursor Rules answer “what lines must never be crossed in Cursor on every turn.” Claude Skills answer “how does Claude Code run this class of SOP when asked.” Agent Skills answer “what shape should that SOP file take so multiple Agents can share it.” They are not substitutes; they are a constraint layer + product capability + format standard combination. Classify before you copy someone else’s config pack, and you will avoid the usual dead ends—files present on disk but never loaded, or loaded on every turn when they should be rare.

Further reading: Cursor Rules · Claude Code Skills · Agent Skills open standard · our Workflow / Rules / Skills engineering guide