Cursor Skills Setup: Build Agent Skills in 13 Steps [2026]

Cursor shipped Agent Skills as a first-class part of its Customize panel in 2026, sitting right next to Rules, MCP servers, and plugins. Anthropic’s open Agent Skills standard, the same format Claude Code introduced, reached general availability in Visual Studio Code too, according to Microsoft’s own February 2026 multi-agent development announcement. That cross-editor spread has kept pace with Cursor’s own model lineup, which its documentation expanded to include Grok 4.7, Claude Opus 5.5, and Gemini 3.8 Flash as available models by June 2026, giving teams more choice over which model actually carries out a triggered skill. That means the same portable folder of instructions you build once can, with minor adjustments, run inside Cursor’s Agent, GitHub Copilot in VS Code, and Claude Code.

Search interest backs this up. “Cursor skills” pulls roughly 2,900 monthly US searches and “agent skills” pulls around 8,100, both with low keyword competition, according to DataForSEO’s related-keyword data pulled in September 2026. That is a sign developers are actively hunting for a working setup guide rather than a marketing page, because Cursor’s own documentation covers the concept well but skips a lot of the practical friction: where files actually live, what breaks when a skill will not trigger, and how to keep one skill working across two or three different editors.

This tutorial builds a working Cursor Skill from an empty folder to a packaged, team-shareable plugin in thirteen steps, with a complete example you can copy directly into a project. Budget about 45 to 60 minutes if you are doing this for the first time, less if you have already touched Cursor’s Rules or MCP configuration before.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What Cursor Skills Are (and Why Anysphere Shipped Them Now)

A Cursor Skill is a portable, version-controlled folder that teaches the Agent how to perform a specific, repeatable job. According to Cursor’s official documentation, “Skills package domain-specific knowledge and workflows that agents can use to perform specific tasks.” Practically, that means a directory containing at minimum a single file, SKILL.md, written in Markdown with a short block of YAML metadata at the top.

The format did not originate with Cursor. It came out of Claude Code, and Cursor’s own docs describe it as “a portable, version-controlled package that teaches agents how to perform domain-specific tasks,” per Cursor’s skills reference page. When Vercel developer advocate Lee Robinson posted about the feature rolling into Cursor, he summed it up plainly: “Agent Skills are now available in Cursor. Skills let agents discover and run specialized prompts and code,” in a public post on X. That framing matters because it separates a skill from a plain prompt: a skill can bundle actual scripts, templates, and reference documents alongside its instructions, not just text.

The mechanism behind skill loading is what Anthropic originally called progressive disclosure. Cursor’s Agent does not stuff every installed skill’s full content into context on every request. Instead, it scans the short description field from each skill’s frontmatter, decides which ones are relevant to the current task, and only then reads the full SKILL.md body plus any linked files. That keeps a project with a dozen skills installed from bloating every single prompt, which is the same context-budget problem that made naive prompt-stuffing unworkable at scale.

Cursor also ships with what its documentation calls “a small set of built in skills to improve your general workflows,” meaning you get baseline behavior before writing a single custom one. The interesting part for teams is that skills are not tied to Cursor’s proprietary format the way, say, a VS Code extension is tied to the VS Code extension API. A SKILL.md file with clean frontmatter is close enough to the open standard that it will work, with small path changes, in Cursor, GitHub Copilot, and Claude Code without a rewrite.

Why This Format Is Spreading Beyond Claude Code

The reason this format keeps showing up in more tools comes down to a problem every AI coding team eventually hits: prompting the same instructions over and over, slightly differently each time, produces inconsistent output. A developer types a rough version of the review checklist from memory, another pastes an old Slack message, a third just asks the Agent to “check this like usual” and gets whatever the model feels like producing that day. Skills fix that by turning the instructions into a checked-in artifact that behaves the same way for everyone on the team, on every machine, every time.

That is also why Microsoft moved fast on adopting the same format for GitHub Copilot rather than building a competing one from scratch. Fragmenting the ecosystem into three incompatible ways to package agent instructions would have meant every open-source maintainer writing three versions of the same workflow file to support Cursor, Copilot, and Claude Code users at once. A shared SKILL.md convention, even with the small path differences covered later in this tutorial, means one well-written skill in a public repository is usable by contributors regardless of which of the three tools they happen to run.

Cursor Skills vs MCP Servers vs Rules vs VS Code Extensions

Cursor now has four separate customization systems living under the same Customize panel, and it is easy to reach for the wrong one. Skills package a workflow. MCP servers expose live tools and external data, as covered in our Cursor MCP servers setup guide. Rules set standing behavior and constraints for every conversation. Extensions, the kind you install through Cursor’s VS Code-compatible extensions panel, add editor functionality like syntax highlighting, linting, or debuggers that has nothing to do with the AI agent at all.

Feature	Cursor Skill	MCP Server	Rule	VS Code Extension
What it provides	A packaged workflow, instructions plus optional scripts and templates	Live tools and data connections to external systems	Standing instructions or constraints applied to every relevant chat	Editor functionality: syntax, linting, debugging, UI panels
Primary file	SKILL.md with YAML frontmatter	mcp.json pointing to a command or URL	.mdc or Markdown rule file	.vsix package built from the VS Code extension API
Runtime behavior	Agent reads it and follows the workflow using its existing tools	Agent calls tools the server actually exposes over the protocol	Applied automatically based on file glob or always-on scope	Runs continuously inside the editor process
Can include executable scripts	Yes, as supporting files the agent may run	Yes, the entire server is executable code	No, text only	Yes, full program logic
Portable across AI tools	Largely yes, same open standard in Cursor, Copilot, Claude Code	Yes, protocol is tool-agnostic	No, format is Cursor-specific	No, tied to the VS Code extension API
Typical use case	“Follow this exact code review checklist for pull requests”	“Query our Postgres database” or “open a GitHub issue”	“Always use our internal error-handling pattern”	“Highlight Python syntax” or “run ESLint on save”

The overlap that trips people up is between Skills and MCP. A Skill can tell the Agent to use a specific MCP tool as part of its process, for example, “query the incident-management MCP server, then compare the result against the deployment log.” The Skill supplies the procedure; the MCP server supplies the actual live connection. Confusing the two usually means someone tries to write a Skill that reaches out to a live API directly, which is not what the format is built for. If your workflow genuinely needs to call an external service, build or install an MCP server and reference it from inside your Skill’s instructions instead of trying to cram an API client into a Markdown file.

Prerequisites and Version Requirements

You do not need much to start. Skills are plain text files, so there is no compiler, package manager, or build step required for a basic skill. The requirements below cover what you need for the full tutorial, including the optional VS Code portability step at the end.

Tool	Version / Notes	Why it matters
Cursor desktop app	Current stable build (3.21.x line as of late September 2026, per the third-party tracker cursorhistory.com)	Older builds predate the Skills UI in Customize; check Cursor menu > About Cursor for your exact build
A Git-tracked project	Any version of Git	Project Skills live under version control so teammates get them automatically on pull
Text editor	Cursor itself works fine	SKILL.md is just Markdown, no special tooling needed to author it
Node.js or Python (optional)	Only if your skill bundles an executable script	Needed to run any helper scripts the skill references, not needed for instruction-only skills
Visual Studio Code	1.108 or newer	Required only for Step 13, porting the skill to GitHub Copilot’s Agent Skills support
GitHub Copilot	Any plan with Agent mode enabled	Needed to test the ported skill inside VS Code’s chat

One thing worth flagging before you start: Cursor’s own changelog documents new features by date rather than a single incrementing version number visible to end users, so do not rely on a changelog entry’s date as a stand-in for your installed build number. The same caution applies to models: Cursor’s latest model list added GPT-5.6 and Composer 2.5 by October 2026, and independent benchmarking firm NeuralTrust’s CursorBench 4.0 suite scored Claude Opus 5.5 at 57.8% and Composer 2.5 at 27.7% in its September 2026 results, figures worth weighing before you decide which model should drive a skill-triggered Agent task. Always confirm the actual version from the About dialog.

Step 1-3: Create Your First Project Skill Folder

Step 1: Create the skills directory. Inside your project root, create a folder named .cursor/skills if it does not already exist. This is the documented location Cursor scans for project-level skills, distinct from the .cursor/rules directory you may already have for Rules and the .cursor/mcp.json file for MCP servers.

Step 2: Create a subdirectory for the skill. Each skill gets its own folder, named after the skill itself using lowercase letters and hyphens. For this tutorial, use api-review-checklist as the example. The full path becomes .cursor/skills/api-review-checklist/.

Step 3: Add the required entry file. Every skill needs exactly one file to be recognized: SKILL.md, placed directly inside that folder. The resulting structure looks like this before you add any content:

your-project/
└── .cursor/
    ├── mcp.json
    ├── rules/
    │   └── code-style.mdc
    └── skills/
        └── api-review-checklist/
            └── SKILL.md

An empty SKILL.md file will not do anything yet. Cursor needs the frontmatter fields filled in before it will list the skill in Customize, which is the next step.

Step 4-6: Write the SKILL.md Frontmatter and Instructions

Step 4: Add YAML frontmatter with name and description. These two fields matter more than anything else in the file, because the description is what the Agent reads to decide whether this skill is relevant to the current task, before it ever loads the full body. A vague description means the skill never triggers when you need it, or triggers constantly when you do not.

---
name: api-review-checklist
description: Review REST API endpoint changes for breaking changes, missing validation, and inconsistent error responses. Use this when a pull request modifies files under src/api or adds new routes.
---

Step 5: Write the Markdown instructions below the frontmatter. This is the actual procedure the Agent follows once it decides the skill applies. Be specific and sequential, the same way you would brief a new engineer joining the review rotation. Vague instructions like “review the API carefully” produce inconsistent results, while a numbered checklist produces the same output every time.

# API Review Checklist

When reviewing changes to REST API endpoints, follow this exact sequence:

1. Identify every modified or new route in the diff.
2. For each route, check whether the response shape changed. Flag
   any removed field, renamed field, or changed type as a
   breaking change and require a version bump.
3. Confirm input validation exists for every new or changed
   parameter. Missing validation on user-supplied input is a
   blocking issue, not a suggestion.
4. Check error responses against the project's standard error
   envelope defined in references/error-format.md.
5. Confirm the OpenAPI spec under docs/openapi.yaml was updated
   to match the code. If it was not, flag this explicitly rather
   than silently updating it yourself.
6. Summarize findings as a short list grouped by severity:
   Breaking, Missing Validation, Inconsistent, Documentation.

Step 6: Keep the description under roughly two sentences. Cursor’s Agent scans descriptions across every installed skill before deciding what to load in full, so a bloated description slows down that triage step across your entire skill library, not just this one skill. If you need more nuance, put it in the body, not the frontmatter.

Step 7-8: Add Supporting Scripts, Templates, and Reference Files

Step 7: Add a references folder for material too long to inline. The error-format reference mentioned in Step 5 belongs in its own file rather than pasted into SKILL.md, both for readability and because the Agent only pulls it in when the instructions explicitly point there.

.cursor/skills/api-review-checklist/
├── SKILL.md
├── references/
│   └── error-format.md
└── scripts/
    └── check-openapi-sync.py

Step 8: Reference an executable script the Agent can run. This is the part that separates a skill from a static prompt template. A small Python script that diffs your route definitions against the OpenAPI spec turns step 5 of the checklist from a manual eyeball check into something deterministic.

#!/usr/bin/env python3
"""Compares route decorators in src/api against docs/openapi.yaml.
Exits non-zero and prints missing paths if the two are out of sync."""
import sys, re, yaml

with open("docs/openapi.yaml") as f:
    spec_paths = set(yaml.safe_load(f).get("paths", {}).keys())

code_paths = set()
for line in open("src/api/routes.py"):
    match = re.search(r'@route\("([^"]+)"', line)
    if match:
        code_paths.add(match.group(1))

missing = code_paths - spec_paths
if missing:
    print("Routes missing from OpenAPI spec:", sorted(missing))
    sys.exit(1)
print("OpenAPI spec is in sync.")

Add a line in SKILL.md telling the Agent when to run it: “Before summarizing findings, run scripts/check-openapi-sync.py and include its output in the Documentation section.” The Agent executes it through its own terminal tool, the same way it would run any other shell command you asked for directly, so treat this exactly like giving a live agent session permission to run code, because that is precisely what it is doing.

Step 9: Verify the Skill Loads in Cursor’s Customize Panel

Open Cursor and go to Customize, then select Skills. Your api-review-checklist skill should appear in the list alongside Cursor’s built-in skills and anything installed from the Cursor Marketplace. If it does not show up, the frontmatter is the first thing to check, a missing closing --- delimiter or a stray tab character in the YAML block is enough to make Cursor silently skip the file.

A correctly loaded skill shows its name and the description you wrote, exactly as entered, with no truncation for reasonably sized descriptions. Click into it and Cursor displays the full parsed body, which is a useful sanity check that your Markdown rendered the way you expected, particularly if you used nested numbered lists or code fences inside the instructions.

Customize > Skills

  Built-in
    check general-workflow-helper

  Project (.cursor/skills)
    check api-review-checklist
      Review REST API endpoint changes for breaking changes,
      missing validation, and inconsistent error responses...

Step 10: Test the Skill With a Real Agent Task

Open a chat with Cursor’s Agent inside the project and give it a task that should trigger the skill without naming it directly, since the whole point is automatic discovery based on the description. For the example skill, something like “review the changes in this branch that touch the API” is a fair test.

A working trigger looks like the Agent explicitly acknowledging the skill before proceeding, often phrased as using or applying a named skill, followed by output that mirrors your numbered checklist structure rather than a generic freeform review. If the Agent reviews the code but ignores your checklist format entirely, the skill likely did not trigger, and you are seeing the Agent’s default behavior instead.

Agent: Using skill "api-review-checklist" for this review.

Breaking:
  - GET /users/:id now omits the `lastLogin` field present
    in the previous response shape. Requires a version bump.

Missing Validation:
  - POST /users/:id/roles accepts `role` as a free string with
    no enum check against valid role values.

Documentation:
  - scripts/check-openapi-sync.py reports: Routes missing from
    OpenAPI spec: ['/users/:id/roles']

If the skill never triggers no matter how directly you phrase the request, go back to Step 4 and tighten the description. Broad, hedge-everything descriptions score poorly against the Agent’s relevance matching compared to a description with specific trigger conditions, like naming the exact directory or file pattern the skill applies to.

Step 11: Personal Skills vs Project Skills vs Cloud Agent Skills

Everything built so far is a project skill, committed to .cursor/skills and shared with anyone who clones the repository. Cursor also supports skills that are not tied to a single project. According to Cursor’s Cloud Agent best practices documentation, you can “commit project skills to the repo, sync personal skills for your own Cloud Agents, or publish a skill so teammates can install it,” which describes three distinct distribution paths rather than one.

Personal skills live outside any single repository and follow you across every project you open in Cursor, useful for habits that have nothing to do with a specific codebase, like a personal commit-message format or a preferred debugging sequence. Check the Skills settings panel inside Customize for the exact personal-skills path shown for your installation, since it is user-account-scoped rather than a fixed path you can hardcode into documentation.

Cloud Agent skills matter if your team runs Cursor’s remote agents rather than only the local desktop Agent. A skill synced for Cloud Agents is available to those remote sessions the same way it is available locally, which matters for teams that kick off long-running agent tasks from cursor.com/agents and expect the same review standards to apply whether the work happened on someone’s laptop or in the cloud.

Step 12: Package a Skill Inside a Cursor Plugin for Team Distribution

Committing a skill to .cursor/skills works for a single repository, but if you want the same skill available across every repository your team touches, package it as a Cursor plugin instead. According to Cursor’s plugins reference, a plugin can bundle multiple skills, MCP servers, rules, agents, commands, hooks, and variables under one distributable unit.

api-standards-plugin/
├── .cursor-plugin/
│   └── plugin.json
└── skills/
    ├── api-review-checklist/
    │   └── SKILL.md
    └── release-notes-writer/
        └── SKILL.md

Cursor’s plugins reference documents that “each subdirectory under skills/ containing a SKILL.md is treated as a skill.” A minimal plugin.json needs a name and version so Cursor’s Marketplace and your team’s internal distribution can track updates:

{
  "name": "api-standards-plugin",
  "version": "1.0.0",
  "description": "Shared API review and documentation skills for the platform team"
}

Once packaged, browse and install plugins, skills, and MCP servers from the Cursor Marketplace with one click through Customize, the same panel used to verify your standalone skill back in Step 9. For an internal team plugin that should not go to the public Marketplace, distribute it through your team’s Cursor dashboard instead, which is also where Team MCP servers get configured and pushed out to everyone’s IDE, CLI, and Cloud Agents at once.

Step 13: Port the Same Skill to VS Code and GitHub Copilot

Because Agent Skills is an open standard rather than a Cursor-only feature, the same SKILL.md content works inside GitHub Copilot in VS Code with a path change. Microsoft’s VS Code Agent Skills documentation states plainly that “Agent Skills is an open standard that works across multiple AI agents, including GitHub Copilot in VS Code, GitHub Copilot CLI, and Copilot cloud agent.”

VS Code’s native convention for workspace skills is .github/skills/<skill-name>/SKILL.md, separate from Cursor’s .cursor/skills path. VS Code also maintains backward compatibility with Claude Code’s original convention, reading from .claude/skills/<skill-name>/SKILL.md at the workspace level and ~/.claude/skills/<skill-name>/SKILL.md for personal skills that follow you across projects, as documented in the VS Code 1.108 release notes.

To create one directly from inside VS Code rather than hand-placing files, open Copilot Chat, select Configure Chat using the gear icon, open the Skills tab, and choose New Skill (Workspace) or New Skill (User), then enter a name and fill in the same frontmatter and instructions you already wrote for Cursor. One portability gap worth knowing about: VS Code’s documentation notes it does not support Claude’s allowed-tools frontmatter field, so if you add tool-scoping metadata for Claude Code later, do not expect VS Code to honor it. Stick to name and description if you want a skill to behave identically across all three tools.

Complete Working Example: An API-Review Skill End to End

Here is the full project layout built across the steps above, ready to drop into any repository that has a REST API and an OpenAPI spec. Copy this structure, adjust the file paths inside the script to match your own routing convention, and commit it to your repository’s .cursor/skills directory.

your-project/
├── .cursor/
│   └── skills/
│       └── api-review-checklist/
│           ├── SKILL.md
│           ├── references/
│           │   └── error-format.md
│           └── scripts/
│               └── check-openapi-sync.py
├── docs/
│   └── openapi.yaml
└── src/
    └── api/
        └── routes.py

The references/error-format.md file referenced in Step 5 should hold your team’s actual error envelope, something concrete the Agent can compare against rather than a vague standard:

# Standard Error Envelope

Every error response must match this shape:

{
  "error": {
    "code": "VALIDATION_FAILED",
    "message": "human readable summary",
    "field": "optional, name of the offending field"
  }
}

Do not return bare strings, arrays, or nested error objects.
HTTP status code must match the error code's documented mapping
in references/status-code-map.md.

With this structure committed, anyone on the team who clones the repo and opens it in Cursor gets the exact same review checklist applied automatically, without needing to know the skill exists or remember to ask for it by name. That consistency, more than any single feature, is the actual argument for building skills instead of relying on ad hoc prompting every time.

Common Pitfalls When Building Cursor Skills

• Writing a description that is too broad. “Helps with code review” matches almost any task, which means the skill either never stands out enough to trigger or triggers so often it interferes with unrelated work. Name the specific file paths, frameworks, or task types the skill applies to.
• Treating SKILL.md as a place to dump an entire style guide. Long, unstructured instructions are harder for the Agent to follow precisely than a short numbered sequence. Move background context into a references file and keep the main instructions procedural.
• Forgetting that scripts run with real permissions. A script referenced from a skill executes through the Agent’s terminal tool exactly like any other command you would type yourself. Do not bundle a script that deletes files, pushes to a remote, or touches production credentials without an explicit confirmation step written into the instructions.
• Mixing MCP responsibilities into a skill. If your instructions describe calling a live API directly with authentication headers, you are trying to build an MCP server inside a Markdown file. Build the MCP server and reference it from the skill instead.
• Assuming personal skills sync automatically to Cloud Agents. They need to be explicitly synced or published, per Cursor’s Cloud Agent documentation. A skill working perfectly on your local desktop Agent will not necessarily be available the first time you kick off a Cloud Agent session unless you have set that up.
• Skipping the closing YAML delimiter. A missing second --- after the frontmatter block is a common copy-paste mistake that makes Cursor silently fail to parse the file rather than throwing a visible error.

Troubleshooting: Skills That Won’t Load or Won’t Trigger

Symptom	Likely Cause	Fix
Skill does not appear in Customize > Skills at all	Malformed or missing YAML frontmatter	Confirm both --- delimiters are present and the file uses spaces, not tabs, inside the YAML block
Skill appears but with a blank description	The description key is missing or misspelled in frontmatter	Re-check the exact key name against a working built-in skill for reference
Agent never triggers the skill on relevant tasks	Description is too vague or too narrow relative to how you phrase requests	Rewrite the description with concrete trigger conditions, file paths, or task keywords
Agent triggers the skill on unrelated tasks	Description overlaps too broadly with common phrasing	Narrow the description to specific directories or explicit task types
Referenced script fails silently	Script path in SKILL.md does not match the actual file location	Use paths relative to the project root, not relative to the skill folder, unless you have confirmed Cursor’s working directory behavior
Skill works locally but is missing in a Cloud Agent session	Personal skill was never synced, or it is a project skill not yet pushed to the branch the Cloud Agent checked out	Commit project skills to the branch in use, and explicitly sync personal skills for Cloud Agents
Teammate does not see the skill after pulling the repo	The skill folder was accidentally excluded by a broad .gitignore rule targeting dotfiles	Check that .gitignore does not blanket-exclude .cursor, only specific subpaths like .cursor/cache if present
Same SKILL.md works in Cursor but not in VS Code Copilot	File placed under .cursor/skills, which VS Code does not scan	Copy or symlink the same skill into .github/skills or .claude/skills for VS Code compatibility
Plugin-packaged skill does not show in the team Marketplace	plugin.json missing required name or version fields	Validate plugin.json against Cursor’s plugins reference structure before publishing

Security Considerations: Skills Run Scripts, Treat Them Like Extensions

A skill that only contains Markdown instructions carries limited risk beyond bad advice reaching your Agent. A skill that bundles scripts is a different story, because those scripts execute with the same access the Agent’s terminal tool already has to your machine. That puts skill review much closer to reviewing a VS Code extension before installing it than to reading a static prompt template.

Before installing a skill built by someone outside your team, read every script it bundles the same way you would read a shell script from an unfamiliar GitHub repository before running it. Do not assume a skill downloaded from a community Marketplace listing has been vetted for supply-chain safety just because it is discoverable inside Cursor’s official interface, the same caution that applies to any package registry applies here too.

For skills your own team writes, keep destructive actions, anything that deletes files, force-pushes, or touches credentials, out of automatically-triggered scripts entirely. Write the instruction as a step the Agent proposes and waits for explicit approval on, rather than a script it runs unattended the moment the skill triggers. That single habit avoids the most common way an otherwise useful skill turns into an expensive accident.

Advanced Tips: Combining Skills, MCP, and Rules Without Conflicts

Cursor’s CLI changelog documents a recent refinement worth knowing about if you use skills from the command line rather than only the desktop app: sticky skills. A skill invoked with a slash entry attaches once when you press Enter, while invoking it with Option+Enter turns it into a sticky custom mode that stays active until you explicitly exit it, useful for a long working session where you want the same review standard applied across many turns rather than re-triggered per message. That is the exact kind of extended session Cursor had in mind when its August 2026 blog post introduced Grok 4.7, a model it pitched specifically for long-running coding work rather than quick one-off completions.

The same changelog notes that managed-skill sync now materializes a skill’s nested Markdown resource files, not just SKILL.md itself, into the local skills directory, so slash-command execution and file references behave the same whether the skill was authored locally or distributed through your team’s managed sync. That matters if your reference files or scripts were not showing up correctly for teammates using a synced, rather than locally authored, copy of a skill.

When a project uses skills, MCP servers, and rules together, keep the division of labor explicit rather than letting them blur. A rule should state standing constraints that apply regardless of task, a skill should describe a specific repeatable procedure, and an MCP server should be the only thing actually reaching outside the editor to touch live systems. Writing a rule that tries to embed a whole multi-step workflow, or a skill that tries to embed live API credentials, is usually a sign the wrong tool was picked for the job. If you are still deciding between building a custom skill or reaching for an existing migration or setup guide instead, start with whichever system the specific problem actually maps to, not whichever one you already know best.

For the canonical specification behind the underlying protocol that MCP servers speak, and how it relates to but differs from the Skills format, see the Model Context Protocol specification repository. For Cursor’s own running list of feature releases, including future changes to how Skills are packaged and synced, check Cursor’s changelog directly rather than relying on third-party trackers for anything beyond a rough version estimate.

A practical pattern for larger teams is to version skills the same way you version any shared library. Bump the skill’s implicit version by noting a changelog at the bottom of SKILL.md itself, since the format has no separate manifest for a standalone skill outside a plugin. When a skill changes behavior in a way that could surprise someone mid-review, a one-line note at the top of the file, something like “Updated 2026-09: now requires the OpenAPI sync check to pass before summarizing,” saves the next person from wondering why the Agent’s output style suddenly shifted between one pull request and the next.

Frequently Asked Questions

Do Cursor Skills cost extra on top of my Cursor subscription?
Skills themselves are just files you write and commit to your project, so there is no separate fee to create or use one. Any cost comes from the underlying model usage your Agent conversation already consumes, the skill does not add a metering layer of its own.

Can I use Cursor Skills without writing any scripts?
Yes. A skill can be nothing more than a SKILL.md file with frontmatter and Markdown instructions. Scripts, templates, and reference files are optional additions, not a requirement.

What is the difference between a Cursor Skill and a Cursor Rule?
A Rule sets standing behavior that applies broadly, like a coding style constraint. A Skill packages a specific, triggerable workflow the Agent runs when the task matches its description, and can bundle scripts and reference files a Rule cannot.

Will a skill I write for Cursor work in Claude Code without changes?
Mostly yes for the core name and description fields, since both use the same open Agent Skills format. Directory conventions differ, Cursor uses .cursor/skills while Claude Code uses .claude/skills, so you will need to place or symlink the same folder in both locations to use it in each tool.

How many skills can I install in a single project before performance suffers?
Cursor’s documentation does not publish a hard numeric limit. Because the Agent only reads full skill content for ones it judges relevant to the current task, based on the short description field, a reasonably sized library of well-scoped skills should not meaningfully slow down unrelated conversations. A large number of overly broad descriptions is more likely to cause problems than the raw count of skills installed.

Do I need an MCP server to build a useful skill?
No. Plenty of useful skills, like a code review checklist or a documentation format enforcer, need nothing beyond the Agent’s existing file-reading and terminal tools. MCP servers become relevant only when a skill’s workflow genuinely requires reaching an external system the Agent cannot otherwise access.

Can I publish a skill publicly for other Cursor users to install?
Yes, by packaging it as a plugin with a plugin.json manifest and submitting it through Cursor’s Marketplace flow inside Customize. Teams that only want internal distribution can skip the public Marketplace and share the plugin through their own team dashboard instead.

Is the Skills feature available on every Cursor plan?
Cursor’s documentation describes Skills as part of the standard Customize interface rather than gating the ability to write and use project-level skills behind a specific paid tier. Team-wide managed sync and publishing to a team Marketplace are administrative features tied to team and business plans, so check your specific plan’s admin controls if you need organization-wide distribution rather than personal or project-level use. As of October 2026, Cursor’s Pricing page lists the Teams plan at $40 per user per month, which is the tier that unlocks that organization-wide sync and Marketplace publishing.

Related Coverage

• VS Code vs Cursor Remote Dev: 12-Step SSH Setup [2026]
• Cursor MCP Servers vs VS Code Agents: 12 Steps [2026]
• VS Code Extensions in Cursor: 12 Steps, 45 Min [2026]
• VS Code to Cursor Migration: 12 Steps, 60 Min [2026]
• React vs Vue Charts Setup: 12 Steps, 90 Min [2026]