Which Tool: Claude Code vs Cursor vs VS Code (and Why Portability Matters)

In short

The same engine compiles to three targets: Claude Code (plugin, subagents, hooks, rules, MCP), Cursor (.mdc rules with frontmatter + mcp.json), and the universal AGENTS.md — the route for VS Code Copilot, Codex, Jules, Zed and everything else; there is no separate "vscode" target. The point is portability: one validated spec instead of hand-written configs in every repository. Switch tools, and you export the same engine to the new target — the discipline doesn't get rewritten. The level of guarantee differs between targets, and this article is honest about where rules are enforced by process and where they stay advice — plus a practical answer on how to pick your target.

What it is

The same engine compiles to three real targets (verified in the code — ExportTarget = 'agents-md' | 'claude-code' | 'cursor'; the dispatcher throws on anything else):

One engine, three carriers with different levels of guarantee

Claude Code — a .claude-plugin package + subagents + commands + .claude/rules/ rules + hooks + .mcp.json.
Cursor — rules as .cursor/rules/*.mdc with frontmatter + .cursor/mcp.json.
VS Code and everything else — through the universal AGENTS.md at the repository root. There is NO separate vscode target: VS Code (Copilot), Codex, Jules, Zed and dozens of other agents read AGENTS.md, so that's your route for VS Code.

Why it matters (portability)

Without a common standard, you hand-write AGENTS.md or .claude in every new repo, for every tool, every time. The engine gives you one validated spec, from which a deterministic compiler builds a native package for any of the three targets. Switch tools, and instead of rewriting the discipline you export the same engine to the new target. For professionals that's the whole value: a portable, versionable configuration standard for AI agents instead of scattered hand-made files.

The key difference — level of guarantee (honestly)

This is the most important thing when choosing. A guarantee is either ENFORCED (an exit code physically blocks the action) or ADVISORY (a strict text instruction the model follows, but violating it is technically possible).

Guarantee	Claude Code	Cursor	AGENTS.md / VS Code
Guard against dangerous commands (`rm -rf`, `DROP TABLE`, `git push --force`)	ENFORCED (PreToolUse hook, exit code blocks)	ADVISORY text	ADVISORY text
Invariants/rules (tenancy, i18n, migrations)	ADVISORY + ENFORCED once the Portable Safety Floor ships	ADVISORY + floor (roadmap)	ADVISORY + floor (roadmap)
Verify gate / done gate	ADVISORY until wired into pre-commit/CI (roadmap)	ADVISORY	ADVISORY
Prism verdicts / veto	ADVISORY (the model is instructed to obey)	ADVISORY	ADVISORY

Today a hard block exists only in Claude Code — via the PreToolUse hook (confirmed: hooksFiles() emits hooks for Claude only). The portable git pre-commit + CI floor, which would give ENFORCED on Cursor and AGENTS, is in development (P0 roadmap). Until it ships, "enforced" means "Claude PreToolUse only," and we label that right inside the package.

Guard against dangerous commands (rm -rf, DROP TABLE, git push --force): the level of guarantee today

Claude CodeENFORCEDPreToolUse hook, the exit code physically blocks

CursorADVISORYa strict text instruction; violating it is technically possible

AGENTS.md / VS CodeADVISORYa strict text instruction; violating it is technically possible

The portable git pre-commit + CI floor that will bring ENFORCED to Cursor and AGENTS.md is in development (P0 roadmap)

One important nuance about Cursor: its own Project Rules (always / auto-glob / agent-requested / manual) are a free built-in feature, and they match our rule activation model precisely on Cursor. Our difference here isn't "we're better than Cursor Rules" — it's that one spec compiles to three targets, plus glob self-specialization to your stack at install time.

How to choose

You need maximum enforced protection right now → Claude Code (the only one with an exit-code block today).
You work in Cursor → take the cursor target: rules land in native .mdc, MCP in .cursor/mcp.json.
VS Code / Copilot / any other agent → the universal AGENTS.md at the root.
Not sure / you switch tools → that's exactly the argument for portability: buy the engine once, export it to any target.

Claude Code

you need maximum enforced protection right now — the only one with an exit-code block today

Cursor target

you work in Cursor: rules in native .mdc, MCP in .cursor/mcp.json

AGENTS.md

VS Code / Copilot / any other agent — one universal file at the repo root

Switch tools and you export the same engine to a new target — no configs get rewritten

Worked example

Input: half the team works in Claude Code, half in Cursor, and a CI bot drives Copilot in VS Code. One Quest engine.

What the engine does: from a single laskoff-mod/v1 spec, the compiler exportMod(spec, target) produces three packages:

for Claude — .claude/agents/*.md, .claude/commands/quest.md, .claude/rules/*.md, .claude/hooks/*.sh registered in .claude/settings.json (a real guard hook + route-engine), .mcp.json, and a thin CLAUDE.md;
for Cursor — .cursor/rules/*.mdc + .cursor/hooks.json with the same guard script (beforeShellExecution — it blocks dangerous commands here too) + .cursor/mcp.json;
for VS Code and the rest — a single AGENTS.md at the root (MCP wiring goes inside it as a JSON block).

Result: the team's discipline is identical everywhere, and the guard against rm -rf / physically fires both in Claude Code (PreToolUse) and in Cursor (beforeShellExecution); on AGENTS.md targets the hard backstop comes from the portable safety floor — the .engine/hooks/pre-commit git hook plus the engine-guard.yml CI check, both already shipped in every package. Nobody rewrote a config by hand — three packages built from one source. This difference in guarantees is exactly what we print honestly, so that you choose your tool with open eyes.