Cursor → Claude Code — Migration Feasibility

I. TL;DR + Verdict

Current Spend

$860/wk

Cursor Ultra, $200/mo plan

Claude Code

~$200/mo

Max plan, flat rate

Migration Risk

Medium

PCRM rules/skills need porting

Verdict

HYBRID

Keep both

Verdict: Hybrid

HYBRID — Keep Cursor as primary IDE, add Claude Code as power tool for heavy autonomous work. Eric's $860/week Cursor spend (1,133 prompts, 71% Opus) is extreme — but the PCRM workspace (AGENTS.md, .cursor/rules/, .cursor/skills/, .cursor/commands/) represents weeks of accumulated system design that doesn't port trivially. Claude Code's strengths (autonomous multi-file work, subagents, 200K context) complement Cursor's strengths (IDE integration, visual diffs, inline edits). The play: use Claude Code Max ($200/mo) for heavy building sprints (Donna, Wenhao) while keeping Cursor for daily PCRM operations. Target: cut total AI spend from ~$3,400/mo to ~$1,400/mo by routing 60% of heavy work to Claude Code.

II. Executive Assessment

Eric's Current Stack

Metric	Value	Detail
Weekly spend	$860.73	1,133 requests over 7 days¹
Daily average	~$123/day	Range: $9.67 (light) to $205.56 (heavy)¹
Primary model	claude-4.6-opus-high	71.3% of spend ($613.64/week)¹
Monthly run rate	~$3,400/mo	At current pace¹
Plan	Cursor Ultra ($200/mo)	Overage billed at API rates²
Workspace investment	PCRM system	AGENTS.md + 24 commands + 21 skills + rules³

Spending Reality Check Eric is spending $3,400/month on AI coding tools. Penny spends $40. The question isn't "should Eric spend less" (obviously yes) — it's "can he spend less without losing the PCRM system that makes him productive?"

What Claude Code Offers

Capability	Description
Autonomous multi-file operations	Reads entire codebase, edits multiple files, runs tests, commits⁴
200K context window (1M beta)	vs Cursor's increasingly restricted context retrieval⁴⁵
CLAUDE.md project memory	Hierarchical: global → project → local. Analogous to AGENTS.md + .cursor/rules/⁶
Subagents (Task tool)	Spawn parallel workers for independent tasks — similar to Cursor's Task⁷
Agent Teams (experimental)	Peer-to-peer multi-agent coordination (see companion report)⁸
Hooks system	Lifecycle automation: session start/end, pre/post tool use⁹
MCP integration	Connect to databases, APIs, external services via open protocol¹⁰
/init and /config	Project bootstrap and settings UI⁶

What Eric Would Lose

Feature	Cursor Today	Claude Code Equivalent
Visual IDE	Full VS Code — explorer, file tree, highlighting	None — terminal only⁴
Tab completion	Cursor's autocomplete is unmatched	None⁴
Inline editing (Cmd+K)	Small precise edits — Cursor's sweet spot	No equivalent⁴
Multi-model support	Routes to GPT, Gemini, Claude	Claude only¹¹
.cursor/commands/ (24)	Cursor-specific prompt templates	No direct equivalent — use CLAUDE.md sections or slash commands⁶
.cursor/skills/ (21)	Read-on-demand capability docs	No direct equivalent — MCP servers or CLAUDE.md includes¹⁰
.cursor/rules/ (modular)	.mdc format with YAML frontmatter	.claude/rules/*.md — similar concept, different syntax⁶
AGENTS.md workspace	Root system prompt	CLAUDE.md is the analog — content portable, wiring is not⁶

Key Insight The PCRM workspace is Eric's real asset — not the IDE. The question is how much of AGENTS.md + rules + skills + commands can be ported to CLAUDE.md, and at what effort.

Bottom Line

Migration Decision Matrix

Should Eric switch fully? NO — too much PCRM-specific tooling to abandon
Should Eric add Claude Code? YES — for heavy autonomous work ($100–200/mo Max)
Migration effort to hybrid: ~8–16 hours (port AGENTS.md, key rules, key commands)
Key risk: Maintaining two systems adds complexity. Eric hates complexity.

III. Architecture Deep Dive

Cursor's Architecture

Cursor is a VS Code fork with an AI integration layer bolted on top. The architecture routes through several key systems:

Model routing: AI requests route through Cursor's proxy to multiple providers — Anthropic, OpenAI, Google. Eric uses Opus 71% of the time, but can fall back to Sonnet, GPT-4o, or Gemini.
Context retrieval: @-mentions, codebase indexing, recently viewed files, lint errors, open tabs. Increasingly restricted — @codebase has been removed, agent retrieves only 2–5 files per query.⁵
Agent mode: Sequential tool calls — read, write, search, terminal. Single-threaded execution loop.
Task tool: Spawns a subagent in isolated context. Returns a result to the parent. Useful for parallelism.
Rules: .cursor/rules/*.mdc files with YAML frontmatter (glob patterns, always-apply, agent-requested, etc.).
Commands: .cursor/commands/*.md — user-triggered prompt templates. Eric has 24 of these.
Skills: .cursor/skills/*/SKILL.md — read-on-demand capability extensions. Eric has 21.

Claude Code's Architecture

Claude Code is a terminal-native CLI that runs an agentic loop directly against Anthropic's API. Fundamentally different design philosophy — no IDE, no visual layer, pure text-in/text-out.

Installation: npm install -g @anthropic-ai/claude-code — runs in any terminal.
API: Direct calls to Anthropic. Claude only — no multi-model fallback.⁴
Context: Reads entire project at startup. CLAUDE.md loaded as system prompt. 200K context window (1M beta).⁴
Agentic loop: Plan → execute → verify → iterate. More autonomous than Cursor — designed to run longer without human intervention.
Subagents: Spawn isolated workers via Task tool, return results. Same pattern as Cursor's Task.⁷
Agent Teams: Peer-to-peer multi-agent coordination. Experimental but powerful for large codebases.⁸
Memory: CLAUDE.md hierarchy — global (~/.claude/CLAUDE.md) → project (./CLAUDE.md) → local (./subdir/CLAUDE.md). Plus /memory command for session notes.⁶
Hooks: Shell commands or LLM prompts triggered at lifecycle events — session start/end, pre/post tool use.⁹
MCP: Open protocol for external tool integration — databases, APIs, web search, custom services.¹⁰

PCRM Portability Matrix

This is the critical analysis. For each PCRM component, how hard is it to port to Claude Code?

Component	Cursor Implementation	Claude Code Equivalent	Effort	Notes
AGENTS.md	Root file, read every session	CLAUDE.md — same concept, content portable	LOW	Copy content, adjust format⁶
SOUL.md / USER.md	Referenced from AGENTS.md	Include in CLAUDE.md or reference via CLAUDE.md	LOW	Direct copy
MEMORY.md	Read/write via agent	Read/write via agent — identical pattern	NONE	Already portable
.cursor/rules/ (5 files)	.mdc format with YAML frontmatter	.claude/rules/*.md — similar but no frontmatter	LOW	Strip YAML, content portable⁶
.cursor/commands/ (24)	Cursor-specific prompt templates	No direct equivalent — slash commands or CLAUDE.md sections	MEDIUM	Major effort — each command needs rewriting
.cursor/skills/ (21)	Read-on-demand capability docs	MCP servers or CLAUDE.md includes	HIGH	Most complex migration piece
CRM CLI (cli.js)	Called via Shell tool	Called via bash — identical	NONE	Already portable
Research tools	Called via Shell tool	Called via bash — identical	NONE	Already portable
Web search / browser	Built into Cursor	Needs MCP server (e.g., Brave Search MCP)	MEDIUM	MCP setup required
crm/state/ files	Read/write via agent	Read/write via agent — identical	NONE	Already portable

Portability Summary ~60% of the PCRM system is already portable (AGENTS.md, MEMORY.md, CLI tools, state files). The remaining 40% — commands, skills, and Cursor-specific features — is where the migration effort lives.

IV. Real-World Constraints

Cost Comparison

Option	Monthly Cost	Usage Model
Current: Cursor Ultra	$200/mo plan + ~$3,200/mo overage = ~$3,400/mo	1,133 req/week, 71% Opus¹
Option A: Claude Code Max only	$200/mo flat	~200–800 prompts per 5hr window¹²
Option B: Claude Code API only	~$180–360/mo (at $6–12/day)	Token-based, no ceiling¹³
Option C: Hybrid (recommended)	Cursor Pro ($20) + CC Max ($200) = ~$220/mo	Route heavy work to CC, light edits to Cursor²¹²
Option D: Hybrid + overage buffer	Cursor Pro ($20) + CC Max ($200) + ~$200 overage = ~$420/mo	More realistic for Eric's volume¹²¹²
Penny's reference point	$40/mo total ($20 ChatGPT + $20 Claude)	Disciplined usage, no agent workflows¹⁴

The $38K/Year Question The gap between Option C ($220/mo) and Eric's current spend ($3,400/mo) is $3,180/mo — $38K/year. Even Option D ($420/mo) saves $36K/year. This isn't optimization. This is a spending problem. But: Eric's spend buys him the PCRM research engine, 18 deployed reports, and the Donna/Sourcy/Talent Coop pipeline. The question is whether the same output is achievable at 1/8th the cost.

Workflow Constraints

Key friction points that affect daily productivity:

#	Constraint	Impact
1	Terminal-only workflow	No visual code browsing. Eric would need a separate editor open alongside Claude Code. The hybrid approach (Cursor for visual, CC for generation) solves this but adds context-switching.⁴
2	Single model provider	Claude Code = Claude only. Eric currently uses Opus (71%), Sonnet (12%), and occasionally GPT/Gemini. Losing model diversity means losing fallback options.¹¹
3	Context sharing	Cursor and Claude Code don't share context. Switching between them means re-establishing project understanding. CLAUDE.md and .cursor/rules/ can be kept in sync via symlinks.¹⁵
4	Compact discipline	Claude Code has explicit `/compact` command. Cursor doesn't. This is actually a CC advantage — but Eric needs to build the habit. Each session should `/compact` at 30K+ tokens.¹⁴

Known Issues

Cursor Issues

Context retrieval degradation — @codebase removed, agent retrieves only 2–5 files per query⁵
Plan Mode slowdowns — 8-minute generation times vs 10 seconds in Agent Mode⁵
Increasing pricing pressure on heavy users

Claude Code Issues

No session persistence across terminal restarts
Permission prompts interrupt autonomous flow (workaround: allowed tools in settings.json)
No visual diff review — must trust terminal output

What Practitioners Report

One developer cut costs from $830/mo to $80/mo switching to Claude Code¹⁶
The recommended hybrid: "Claude Code for building features, Cursor for editing and reviewing"¹⁷
Common pattern: brainstorm in Claude Desktop → generate in Claude Code → review in Cursor¹⁸
Risk: maintaining two systems adds cognitive overhead. Eric already manages 24 commands + 21 skills. Adding a parallel CLAUDE.md system doubles maintenance.³

V. Critical Assessment

The Hype

The narrative is seductive: “I switched to Claude Code and saved 10x on AI costs.” Blog posts show dramatic before/after numbers. But Eric’s situation is different from most devs — his PCRM workspace is a custom operating system, not just a code editor. Switching tools means porting the OS, not just the editor.

Adversarial Challenges

Lens	Challenge	Analysis
Inversion	“What if Cursor’s visual IDE is worth the premium?”	Eric’s PCRM work isn’t just coding — it’s research (reading HTML reports), CRM operations (scanning messages), and orchestration (running 24 commands). These are fundamentally visual tasks. Terminal-only Claude Code would force him to maintain a separate editor anyway, negating the simplicity argument.
Base rates	“What’s the historical success rate for tool migrations mid-project?”	Most developers who switch tools mid-stream report 2–4 weeks of reduced productivity. Eric has 3 active projects (Donna, Sourcy, Talent Coop) with real deadlines. Migration downtime = real cost. The $38K/year savings means nothing if it costs a client.
Survivorship	“Are the ‘I saved 10x’ stories representative?”	Selection bias: people who successfully switched write blog posts. People who tried and reverted don’t. The namiru.ai story ($830→$80) came from a developer doing simpler work — not running a 24-command personal CRM system with 21 skills.¹⁶
Incentive mapping	“Who benefits from the ‘switch to Claude Code’ narrative?”	Anthropic. Every user who leaves Cursor for Claude Code sends token revenue directly to Anthropic instead of through Cursor’s proxy. The narrative serves Anthropic’s competitive positioning against Cursor, not necessarily the developer’s interest.
Time horizon	“Is this a permanent advantage or a temporary arbitrage?”	Cursor is likely to add autonomous capabilities (they’re already improving Agent mode). Claude Code may raise prices as adoption grows. The cost gap may narrow. Switching now for cost savings is timing-dependent, not structural.

Hype vs Reality

What’s Real About Switching

$38K/year savings is real money, not theoretical
Claude Code’s 200K context window genuinely exceeds Cursor’s increasingly restricted context
Autonomous multi-file operations are genuinely more capable in Claude Code
CLAUDE.md hierarchy mirrors AGENTS.md + rules — the concept is portable
/compact command is a real discipline tool that Cursor lacks

What’s Hype

“10x cost savings” assumes equivalent output — unproven for Eric’s specific workflow
PCRM commands (24) and skills (21) don’t trivially port — weeks of effort
Terminal-only for a research/CRM workflow is a genuine downgrade
Single-model lock-in loses fallback options (Eric uses Sonnet 12% of the time for lighter work)¹¹
Maintaining two configuration systems (CLAUDE.md + .cursor/rules/) adds the complexity Eric hates
Eric’s $3,400/mo includes ALL his AI work — research, CRM, coding, writing. Claude Code only replaces the coding part.¹

Honest Assessment

The Spending Discipline Problem The honest truth: Eric doesn’t have a tool problem. He has a spending discipline problem. 71% of his $860/week goes to Opus — the most expensive model. Penny achieves serious work on $40/mo by using Sonnet and compacting aggressively.¹⁴ Before switching tools, Eric should try: (1) route 50% of work to Sonnet instead of Opus, (2) /compact or start fresh sessions more often, (3) avoid letting context windows bloat past 50K tokens. If those three changes cut spend by 50%, the migration question becomes much less urgent.

VI. Migration Guide

Phase 0: Cost Discipline First

Before any migration, implement these in the current Cursor workflow:

Switch default model to Sonnet 4.6 for routine work. Keep Opus for complex reasoning only. Expected savings: 30–40% ($1,000–1,400/mo). Time: 5 minutes — change Cursor settings.
Start new sessions more frequently. Don’t let context bloat past 50K tokens. Use Plan mode to think, Agent mode to execute. Time: habit change.
Use Task subagents for parallel work instead of one long session. Each subagent starts with fresh context. Time: already doing this.

Phase 0 Checkpoint If Phase 0 cuts spend to $1,500–2,000/mo, the urgency to migrate drops significantly. Run Phase 0 for 1 week before proceeding.

Phase 1: Install and Configure Claude Code

Install:

npm install -g @anthropic-ai/claude-code

Subscribe to Claude Max ($200/mo) or set up API key
Create CLAUDE.md in PCRM root: port the essential sections from AGENTS.md (identity, workspace map, memory protocol, safety rules)⁶
Create .claude/settings.json: configure allowed tools, MCP servers, preferred model¹⁰
Test: run claude in PCRM directory, verify CLAUDE.md loads, try a simple task

Time estimate: 2–3 hours.

Phase 2: Port Core PCRM Infrastructure

Priority order for porting:

#	Component	Work	Estimate
1	AGENTS.md → CLAUDE.md	Core identity + workspace map	1 hour
2	SOUL.md + USER.md	Include or reference from CLAUDE.md	30 min
3	.cursor/rules/ → .claude/rules/	Strip YAML frontmatter, content identical⁶	1 hour
4	Top 5 commands	/assist, /remember, /prmupdate3, /dunbar, /eric → CLAUDE.md custom slash commands or detailed sections	4–6 hours
5	Top 3 skills	twitter, research-report, cursor-usage → MCP servers or CLAUDE.md instructions¹⁰	4–8 hours

Total: 10–16 hours. Spread over 1 week.

What’s Already Portable The CRM CLI (node crm/cli.js), research tools (node crm/research.js), and all state files work identically in both tools. No porting needed for these — they’re bash commands.³

Phase 3: Hybrid Workflow

Daily workflow recommendation:

Time / Task	Tool	Why
Morning PCRM ops	Cursor	/daily, /assist, /dunbar, /eric — visual, message-scanning work
Deep building sprints	Claude Code	Donna features, Wenhao app, heavy refactoring — autonomous multi-file work
Research reports	Either	/deepmarketresearch works in both — it’s CLI-driven
Quick edits	Cursor	Inline edits, Tab completion, small fixes
Review	Cursor	Visual diffs, code browsing, linting

Decision Rule If the task touches 5+ files and can run autonomously for 10+ minutes → Claude Code. Everything else → Cursor.

Phase 4: Evaluate and Adjust

After 2 weeks of hybrid usage:

Compare total spend (Cursor + Claude Code) to pre-migration
Track which tasks naturally gravitate to which tool
Identify any PCRM commands that NEED visual IDE (these stay in Cursor permanently)
If Claude Code handles >60% of heavy work: consider downgrading Cursor Ultra → Pro ($20/mo)²

VII. Verdict & Recommendations

Technology Verdict

HYBRID — Don’t Switch. Augment.

Keep Cursor as the primary IDE for PCRM operations, visual work, and quick edits. Add Claude Code Max ($200/mo) for heavy autonomous building sprints. But FIRST: implement cost discipline in current Cursor usage (Phase 0). Target total spend: $400–600/mo down from $3,400/mo — an 80%+ reduction without abandoning any tooling.

Specific Recommendations

This week Phase 0 — cost discipline. Switch Cursor default to Sonnet. Compact aggressively. This alone could save $1,500/mo with zero migration effort.

Next week Phase 1 — install Claude Code. Get it running with a basic CLAUDE.md. Test on one bounded task (e.g., a Donna feature). Don’t port commands yet — just test the raw tool.

Month 1 Phase 2+3 — port and hybridize. Port core PCRM infrastructure. Establish the hybrid workflow. Measure spend.

Month 2 Phase 4 — evaluate. If hybrid is working and spend is down, consider downgrading Cursor Ultra → Pro. If not, at least the cost discipline from Phase 0 is paying off.

Full switch to Claude Code only NOT RECOMMENDED. Terminal-only workflow is a genuine downgrade for PCRM’s visual/research/CRM work. The 24 commands + 21 skills represent weeks of system design. Porting all of it is a month-long project with uncertain ROI. The hybrid approach captures 80% of the savings at 20% of the effort.³

What Would Change the Verdict

Upgrade to FULL SWITCH if: Claude Code ships a VS Code extension with visual IDE features + native support for custom commands/skills
Downgrade to CURSOR ONLY if: Cursor fixes context retrieval, adds /compact, and reduces cost-per-prompt by 50%+⁵
The key variable: Cursor’s pricing. If they introduce token-based pricing that matches Claude Code API rates, the cost argument evaporates.²

Next Steps

Phase 0 NOW: Change Cursor default model to Sonnet — 5 minutes
Track spend this week with cursor-usage.js — already instrumented¹
Install Claude Code by Wednesday: npm install -g @anthropic-ai/claude-code — 10 minutes
Port AGENTS.md → CLAUDE.md over the weekend — 2–3 hours⁶
Run first Claude Code sprint on Donna adapter work — 2 hours
Review spend comparison in 2 weeks — decide on Cursor downgrade

VIII. Open Questions

Can Cursor commands (.cursor/commands/) be converted to Claude Code slash commands? What’s the format difference?
Do Claude Code’s MCP servers provide equivalent functionality to Cursor’s built-in web search and browser tools?¹⁰
What’s the actual token consumption difference for the same task in both tools? Need head-to-head testing.
Will Cursor respond to Claude Code competition with lower pricing or better autonomous capabilities?²
Can CLAUDE.md and .cursor/rules/ be kept in sync automatically (symlinks? build script?)?¹⁵
Is there a Claude Code VS Code extension on the roadmap? This would make the hybrid workflow seamless.

Sources

1. Eric San — Cursor usage data, Feb 15–22 2026 (cursor-usage.js, 1,133 requests, $860.73)

2. Cursor — pricing clarification — cursor.com/blog/june-2025-pricing

3. PCRM workspace — AGENTS.md, 24 commands, 21 skills, 5 rules

4. Northflank — “Claude Code vs Cursor: Complete Comparison” — northflank.com/blog

5. Cursor Community Forum — context retrieval degradation and Plan Mode slowdowns

6. Anthropic — CLAUDE.md guide and memory management — claude.com/blog, docs.claude.com

7. claudefast — subagent best practices guide

8. Eric San — Claude Agent Teams tech research (companion report, Feb 22 2026)

9. Anthropic — hooks reference — code.claude.com/docs/en/hooks

10. Anthropic — MCP integration — code.claude.com/docs/en/mcp

11. Cursor — multi-model support documentation

12. Anthropic — Claude Code pricing and rate limits — support.claude.com

13. Anthropic — manage costs effectively — code.claude.com/docs/en/costs

14. Eric San — conversation with Penny Yip, Feb 15 2026 (token cost discipline)

15. solmaz.io — CLAUDE.md to AGENTS.md migration guide

16. namiru.ai — “Why I Switched from Cursor to Claude Code (And Cut My AI Costs by 10x)”

17. aiorg.dev — “Cursor vs Claude Code: Which Ships Faster?”

18. muhammad.dev — “My 2026 Development Workflow: Claude Code Desktop + Cursor”