← Back to Guides · RULES & SKILLS
Cursor Rules vs Skills vs Commands vs Hooks: The Only Diagram You Need (2026)
Short answer: a rule is always-on, a command is something you type, a skill is something the agent decides to load, and a hook is something an event fires whether you're watching or not. Use the decision table below, not vibes. Cursor's own forum has at least three separate threads asking what the difference actually is, which is the best evidence that the docs alone don't settle it — see Rules vs Skills vs Commands vs Hooks and Skills vs. Commands [vs. Rules].
The four primitives, one sentence each
- Rule (
.cursor/rules/*.mdc) — a standing instruction that loads on every turn, or on every turn that touches a matching file glob. No judgment involved; it's just always there. - Command (
.cursor/commands/*.md) — a saved prompt that runs only when you type its name, like/code-review. You decide when, every time. - Skill (
.cursor/skills/<name>/SKILL.md) — a longer playbook the agent itself chooses to open when the task description matches, or that a command points at directly. The agent decides, not you. - Hook — a script your editor or CLI runs automatically on a lifecycle event (before a tool call, after a file edit, on agent stop), independent of any prompt. It can block or modify the action; no model judgment is involved on the hook's side.
The axis that actually separates them: who decides it runs, and how often. Rules: always (or by path). Commands: you, manually. Skills: the agent, by matching a description. Hooks: the event itself, every time it fires, with no exceptions.
Decision table
| Need | Use | Why |
|---|---|---|
| Must apply on every single turn, no exceptions | Rule | Rules are the only primitive that can't be skipped by forgetting to type something |
Only matters on certain paths (app/api/**, *.sql) | Rule, glob-scoped | Keeps the always-on text short and targeted |
| You want to trigger it yourself, on demand | Command | Commands are manual by design — /release-notes shouldn't run on every turn |
| The agent should decide on its own when this applies, based on what the task looks like | Skill | A skill's description field is the selector; rules and commands can't be conditionally loaded that way |
| The content is longer than a screen, or reads like a how-to rather than a ban | Skill | Stripe webhook setup, RAG chunking strategy, an SEO checklist — these are playbooks, not prohibitions |
| Something must happen (or be blocked) on a lifecycle event, with zero chance of being skipped by a careless turn | Hook | A prompt can be ignored by a busy agent; a hook that runs pre-tool-use cannot |
| A hard ban that must survive even when nobody remembers to invoke anything | Hook (or a short rule, if the event isn't hook-observable) | If you can hook the event (e.g. block writes to .env), do that instead of trusting a rule to be read carefully |
If you answered "rule" to the first two rows, stop — don't also duplicate the same text into a skill. If the standard is long and situational, it's a skill. If the enforcement has to be unconditional and tied to a specific action rather than a topic, it's a hook, not a rule.
Real examples from AgenticKit's kit
AgenticKit installs all four primitives into a repo in one shot, which makes a decent case study for where each one actually gets used:
- Rule: a short, always-on project-conventions rule — tenant scoping from session, no
any, no raw SQL in route handlers. Three or four lines, loaded every turn, because missing it once is the whole risk. See the project-conventions skill for the longer version of this split — the rule stays short on purpose, and the reasoning lives in the skill. - Command:
/audit— a saved prompt you type when you want a full security and performance pass over API routes and queries. Nobody wants that running on every message, so it's a command, not a rule. - Skill:
security-basicsandon-page-seo— multi-page playbooks the agent opens when a task description matches ("add an SEO audit route," "review auth checks"), or when/auditexplicitly points at them. For a ranked, tested rundown of 20 of these, see 20 Best Claude Code Skills in 2026. - Hook (editor/CLI-level, not shipped as a kit file but the natural fourth leg): a
pre-tool-usehook that blocks anyWriteorEdittouching.envorcredentials.json, regardless of what rule text says. This is the category rules can't cover reliably — see the forum's own framing of rules as advisory text versus hooks as enforced gates. For the Claude Code side of this (different config file, different event names), see Claude Code Hooks for Founders for ready-to-paste JSON, or Claude Code Hooks in Production: The Advisory vs Deterministic Rule Nobody Explains for why "advisory" rule text and a deterministic hook aren't interchangeable in the first place.
Common forum complaints (and what they actually mean)
Cursor's docs have been catching up to a product that shipped skills and hooks faster than it documented them. A few recurring threads:
- "My commands aren't showing up in the global directory." Multiple forum posts report commands placed in
~/.cursor/commands/not appearing, especially in CLI or background-agent environments that may not read the same global folder as your editor window. If a command needs to work everywhere, commit it to.cursor/commands/in the repo instead of relying on the global path — see the troubleshooting list in Best Cursor Commands for the full checklist. - "A SKILL.md showed up that I didn't write." Some users report Cursor auto-generating or suggesting skill files they didn't create, which reads as confusing when you expected skills to be purely opt-in. Treat any unexpected
SKILL.mdas something to review and either keep or delete — don't assume it's load-bearing just because it exists. - "There's a
/migrate-to-skillscommand now." Recent Cursor builds have nudged long rules and ad-hoc prompt text toward skills, including a built-in migration command. That's a real signal about where Cursor wants extension logic to live long-term — fewer giant rules files, more scoped skills — but verify the command exists in your installed build before relying on it; it's not consistent across versions per forum reports. - "Is a skill just a command with extra steps?" The forum thread What is the difference between skills and rules? gets asked because skills and commands genuinely overlap: a command can point directly at a skill, and a skill can be invoked as if it were a command. The distinguishing case is autonomy — can the agent reach for it unprompted, from the task description alone? If yes, it has to be a skill, because commands are never auto-invoked.
None of this is a knock on Cursor specifically — it's the expected cost of shipping four overlapping primitives inside a year. The fix on your end is the same regardless of which forum thread you're reading: pick one home per instruction, and don't let the same text live in two files.
When to combine primitives in one project
Most real projects use all four at once, scoped by the rule above:
- A short, always-on rule for the two or three things that must never slip (tenant isolation, secrets, output format).
- A handful of skills for anything that reads like documentation — payment integrations, testing conventions, SEO checklists — loaded only when relevant.
- Commands for repeatable multi-step jobs you want to trigger by name:
/ship,/audit,/pr-description. - Hooks for the handful of actions that must be blocked or logged no matter what the prompt says — writes to secret files, a lint gate before commit, a notification when the agent stops.
The failure mode to avoid is using a rule where a hook belongs: a rule that says "never commit .env" is advice the agent reads; a hook that blocks the write is enforcement. If the stakes are real, don't leave it to a instruction the model might skim past on a long turn.
Claude Code's equivalent of an always-on rule is CLAUDE.md — for annotated examples of what belongs there versus what should move into a skill instead, see 15 Real CLAUDE.md Files From Production SaaS Repos.
FAQ
What's the single biggest difference between a skill and a command? Who decides it runs. You decide for a command, by typing it. The agent decides for a skill, by matching the task to the skill's description.
Can a rule call a skill, or a command call a skill? A command's prompt can reference and effectively point the agent at a skill by name. A rule is static text, not an invocation — it can mention a skill exists, but can't trigger it the way a command can.
Do hooks replace rules? No. Hooks enforce actions (block this write, run this check). Rules supply context and constraints the model reads. Use a hook when the consequence of being ignored is unacceptable; use a rule when the goal is to shape behavior, not gate it.
Why do commands sometimes not show up in Cursor's CLI even though they work in the editor? The CLI and background/cloud agents don't always read the same global (~/.cursor/commands/) folder your local editor does, per multiple forum reports. Commit commands to the project's .cursor/commands/ folder so every environment checks them out the same way.
Is Cursor moving away from rules in favor of skills? Not away from rules entirely — short, always-on bans still belong in rules. But Cursor's own tooling (including a /migrate-to-skills command in some builds) points toward moving longer playbook-style content out of rules and into skills. Verify what your installed build supports before assuming it's there.
Get all four, wired together
AgenticKit installs rules, skills, commands, and the agents that use them into .cursor/ and .claude/ in one command — the split above is how the kit itself is structured, not just a diagram.
npx agentickit-cursor init --target cursor
For the deeper breakdown on any single pairing, see Cursor Rules vs Skills vs Commands, Cursor Skills vs Commands, and Cursor Commands vs Hooks. For the ranked command and skill lists referenced above, see Best Cursor Commands and 25 Best Cursor Skills for Solo SaaS Founders in 2026 (Ranked).
This decision table is also the page we link to from /skills and /commands whenever a Search Console audit shows a catalog page competing with informational intent for the same query — see the second audit pass that triggered that fix.
Sources
- Cursor forum, Rules vs Skills vs Commands vs Hooks (referenced, not quoted)
- Cursor forum, Skills vs. Commands [vs. Rules] (referenced, not quoted)
- Cursor forum, What is the difference between skills and rules? (referenced, not quoted)
- Cursor docs, Commands
Written by Rakshit Yadav. Published 2026-10-28, last updated 2026-10-28.
Related Tools & Agents
Get rules, skills, commands and hooks in one install
AgenticKit wires all four primitives into .cursor/ and .claude/ for you.
See the full comparison →