cursor-plugin-cc

cursor-plugin-cc

Claude plans. Cursor writes. Claude reviews. A Claude Code plugin that delegates coding execution to Cursor's Composer — without ever leaving the Claude Code TUI.

Plan. Delegate. Ship.

you ▸ /plan add a /health endpoint to our Express app that returns { status, version, uptime }

claude ▸ Plan written to ~/.claude/plans/health-endpoint.md
         (4 acceptance criteria, 3 files to touch, verify with `npm test`)

you ▸ /cursor:from-plan --delegate

plugin ▸ wrote tasks/20260427-1830-health-endpoint.md
       ▸ handing off to cursor-agent (composer-2.5-fast, --force)…

cursor ▸ ✓ src/routes/health.ts          (new, 24 lines)
       ▸ ✓ src/app.ts                    (mounted route)
       ▸ ✓ tests/health.test.ts          (new, 3 passing)
       ▸ done in 11s · chat_id=V1StGXR8_Z

you ▸ review the diff

claude ▸ LGTM. Nit: hard-coded "1.0.0" — pull from package.json instead.

you ▸ /cursor:resume "read version from package.json"

cursor ▸ ✓ src/routes/health.ts          (1 line changed)
       ▸ ✓ tests/health.test.ts          (assertion updated, still passing)
       ▸ done in 4s

That's the whole loop. Claude does the thinking (plan, review). Cursor does the typing (file edits, tests). You stay in one TUI.

Why this is fast: composer-2.5-fast is Cursor's tuned-for-CLI variant — it ships small, well-scoped changes in seconds. Claude Code spends its tokens on planning and reviewing, where thinking actually matters. Two tools, each doing what they're best at.

Install

Preferred — from GitHub:

/plugin marketplace add freema/cursor-plugin-cc
/plugin install cursor@tomas-cursor
/reload-plugins
/cursor:setup

Local, for hacking on the plugin from a checkout:

/plugin marketplace add /Users/you/path/to/cursor-plugin-cc
/plugin install cursor@tomas-cursor
/reload-plugins
/cursor:setup

⚠️ Do not skip /reload-plugins. Right after /plugin install the /cursor:* commands are NOT yet available — Claude Code only picks them up after a plugin reload. If you see Unknown command: /cursor:setup, you forgot this step — run /reload-plugins and try again.

The plugin ships as plain ESM JavaScript with zero runtime dependencies — just the Node stdlib. /plugin install is literally all you need; no npm install, no build step, no dist/ folder. Each slash command runs node "${CLAUDE_PLUGIN_ROOT}/scripts/<cmd>.mjs" directly from the committed source.

The first /cursor:setup run tells you if cursor-agent is missing or unauthenticated. For hacking on the plugin itself (tests, lint, formatting), see Contributing below.

Requirements

• Node.js ≥ 18.18
• A Cursor account — paid for Composer models; free works with --model auto or other entitled models
• cursor-agent on your PATH — install via curl https://cursor.com/install -fsS | bash
• cursor-agent login completed at least once

The flow — three commands, end to end

This is the entire happy path. Three commands inside Claude Code:

┌──────────────────────────────────────────────────────────────────┐
│  1.  /plan <what you want>                                       │
│      → Claude drafts a plan into ~/.claude/plans/<slug>.md       │
│        (the approval dialog appears — you can ignore it,         │
│         the plan file is already on disk)                        │
├──────────────────────────────────────────────────────────────────┤
│  2.  /cursor:from-plan --delegate                                │
│      → plugin reads the newest plan from ~/.claude/plans/        │
│      → rewrites it as tasks/<YYYYMMDD-HHmm>-<slug>.md            │
│        (Cursor-shaped: Goal / Context / Acceptance / Files /     │
│         How to verify / Guardrails)                              │
│      → invokes `cursor-agent -p --force` with prompt:            │
│        "Implement the task in @tasks/…. Follow every section."   │
│      → Cursor reads the @path, writes the code, reports back     │
├──────────────────────────────────────────────────────────────────┤
│  3.  <your verify command>     e.g. `npm test`, `task test`,     │
│                                     `pnpm test <name>`           │
│      → confirm the change is green                               │
└──────────────────────────────────────────────────────────────────┘

What lives where after a run:

Path	Written by	Purpose
~/.claude/plans/<slug>.md	Claude (plan mode)	Source of truth for the plan
tasks/<YYYYMMDD-HHmm>-<slug>.md	This plugin	Cursor-shaped contract — commit this
<your source files>	Cursor	The actual code change

Iterate: if Claude's review of the diff finds something, just run /cursor:resume "fix X" — same Cursor chat, no replanning. For a fresh slice, run /cursor:from-plan --delegate again with a new plan, or /cursor:delegate "<task>" directly without plan mode.

Skip plan mode for quick one-shots: /cursor:delegate "<task description>" skips steps 1–2 and goes straight to Cursor with whatever string you give it. Good for small, obvious work where a plan would be overkill.

What you get

Eleven slash commands under the cursor: namespace:

• /cursor:delegate — hand a coding task to Cursor, foreground or background.
• /cursor:from-plan — turn a Claude Code plan (from plan mode) into a tasks/<file>.md and hand it off to Cursor.
• /cursor:review — read-only code review of your git diff by a Cursor model. Reports findings; never edits files.
• /cursor:adversarial-review — steerable review that challenges the design and approach (assumptions, tradeoffs, failure modes), not just implementation defects. Read-only.
• /cursor:browser — verify a URL / flow in a real browser via Cursor's chrome-devtools MCP.
• /cursor:status — list recent jobs or inspect a specific one.
• /cursor:result — print the final output of a finished job.
• /cursor:cancel — terminate a running job (SIGTERM, then SIGKILL after 5 s).
• /cursor:resume — continue the previous Cursor chat with a follow-up.
• /cursor:sessions — list Cursor's own chat sessions for this repo.
• /cursor:setup — health-check the CLI, list models + configured MCPs, or guide installation.

Plus a cursor-runner subagent you can invoke from inside Claude to delegate well-scoped tasks automatically, and a composer-prompting skill it uses to shape well-specified tasks into tight Cursor prompts.

Why this plugin

Short answer: Composer is genuinely good at most day-to-day coding work — and I don't want a pile of terminal windows to drive it. I want Claude Code to be the orchestrator for everything. The flow that keeps working for me is simple: Claude makes the plan, Composer executes it, Claude reviews the diff. Two tools, each doing what it is best at.

"Why not do the whole thing inside Cursor, then?" Claude Code has a certain magic, particularly around planning. It is not purely about the underlying model — it is the whole rig (long-context sessions, subagents, the TUI, the way tools compose) that, in my experience, only really clicks inside Claude Code.

Cursor CLI has its own plan mode and it is fine, but execution is where Cursor really shines: file edits, applying diffs, crunching through a well-scoped task list in force mode. Cursor 2 and the Composer models are heavily tuned for exactly that CLI use-case. (The same is true of Codex and GPT on OpenAI's side, which is why openai/codex-plugin-cc exists — and which is what I borrowed from heavily when building this plugin. Credit where due.)

So: Claude plans, Cursor writes, Claude reviews, repeat. Glued together by seven slash commands and one subagent.

A second opinion: /cursor:review

The core loop stays Claude plans, Cursor writes, Claude reviews — that is where Claude Code earns its keep. But sometimes you want a second reviewer on the same diff: a different model with a fresh perspective, or a deeper pass from gpt/opus/gemini while Claude keeps its context for orchestration. That is what /cursor:review is for.

It is modelled on openai/codex-plugin-cc's /codex:review, adapted to the Cursor CLI: the plugin collects the git diff itself (working tree or branch vs a base), hands it to a Cursor model with a strict review-only prompt, and returns the findings verbatim. It never edits your files — a post-flight check fails the job if the run touches the working tree, so a review can't quietly turn into an edit. See /cursor:review under Usage for flags and examples.

Usage

/cursor:delegate <task...>

Hand a coding task to cursor-agent -p ….

Flag	Default	Effect
--model <id>	auto (or $CURSOR_PLUGIN_CC_DEFAULT_MODEL)	Aliases → real Cursor ids: composer/fast → composer-2.5-fast, composer-full → composer-2.5, sonnet → claude-4.6-sonnet-medium, opus → claude-opus-4-7-high, gpt/codex → gpt-5.3-codex, grok → grok-4.3, gemini → gemini-3.1-pro, auto → auto. Unknown or retired ids (e.g. composer-2, composer-2-fast) are forwarded as-is. auto lets Cursor pick whatever model your account is entitled to — safe if you don't have a Composer seat. Run /cursor:setup --print-models for the live list.