Migrating from Traditional IDEs

You have ten years of muscle memory in VS Code or JetBrains. Your keybindings are wired into your fingers, your extensions are tuned exactly how you like them, and you can navigate a codebase blindfolded. Then a teammate ships a feature in an afternoon that would have taken you two days, and you find out they described it to an agent instead of typing it. The switch feels risky: you do not want to lose the setup you spent years building just to chase a faster workflow.

You do not have to. This playbook moves you from a traditional IDE to Cursor, Claude Code, or Codex without throwing away your settings, keybindings, or git flow — and it shows you the one habit that actually changes: going from “write every line” to “describe the change, review the diff.”

What You’ll Walk Away With

• Your VS Code or JetBrains settings, keybindings, and extensions imported into your new tool (or a clear list of what won’t transfer and why)
• A CLAUDE.md / AGENTS.md / .cursor/rules scaffolded from your existing repo conventions so the agent matches your house style on day one
• A copy-paste refactoring prompt that demonstrates the describe-don’t-write workflow on a real module
• A “When This Breaks” checklist for the failure modes every migrating developer hits in week one

Pick Your Migration Path

The smoothest path depends on which IDE you’re leaving and whether you want to keep a graphical editor or move to the terminal.

Cursor

Best path from VS Code — Cursor is a VS Code fork, so the import is near-instant and your extensions, themes, and keybindings come along.

1. Install Cursor, then on first launch choose Import from VS Code (or run the Cursor: Import VS Code Settings command from the palette). This pulls settings.json, keybindings.json, installed extensions, and themes.

2. Verify your extensions resolved. Cursor installs from the Open VSX registry, not the Microsoft Marketplace, so a few proprietary extensions (notably the C/C++ and C# debuggers and some Microsoft-only tools) may be missing. Note the gaps and find Open VSX alternatives.

3. Coming from JetBrains instead? There’s no one-click import. Install the IntelliJ IDEA Keybindings extension to keep your shortcuts, then re-add language support and your debugger config manually.

4. Learn the four AI entry points: Cmd/Ctrl+K for inline edits, Cmd/Ctrl+I for Agent mode, the chat sidebar for questions, and Tab to accept multi-line suggestions.

Claude Code

Best path if you want to keep your editor — Claude Code is a terminal tool, so you don’t migrate away from VS Code, JetBrains, or Vim. You add an agent alongside them.

1. Install the CLI: npm install -g @anthropic-ai/claude-code, then run claude in your project root.

2. Keep your existing editor open for reading and manual edits. Run claude in a split terminal (or use the official VS Code / JetBrains extension) and delegate multi-file work to it.

3. Scaffold a CLAUDE.md so the agent knows your conventions — run /init inside the REPL to have Claude Code draft one from your repo, then edit it.

4. Vim users: nothing changes about your editor. Drop to the terminal, run claude "...", and review the result with git diff in your normal flow.

Codex

Best path for parallel and asynchronous work — Codex spans the CLI, IDE extension, web App, and Cloud, so you can keep your editor and hand off well-defined tasks to run in the background.

1. Install the CLI: npm install -g @openai/codex, then run codex in your project and sign in with your ChatGPT account.

2. Codex uses AGENTS.md for project instructions instead of importing IDE settings — there’s nothing to migrate from settings.json. Run /init inside the TUI to scaffold one.

3. Keep your IDE for interactive editing. Use the Codex IDE extension for in-editor tasks, or fire off longer jobs to Codex Cloud and review the diffs when they finish.

4. Set the autonomy level explicitly with --ask-for-approval (untrusted, on-failure, on-request, or never) and a --sandbox mode (read-only, workspace-write, danger-full-access) so the agent’s boundaries match your comfort level.

Tip

Copy-paste prompt for importing your editor config (Cursor):

“Read my imported keybindings.json and settings.json. List any keybindings that conflict with Cursor’s AI shortcuts (Cmd/Ctrl+K, Cmd/Ctrl+I). Then check my installed extensions against the Open VSX registry and flag any that aren’t available there, with a suggested open-source alternative for each so I can replace the ones that didn’t transfer.”

Teach the Agent Your Conventions

A traditional IDE enforces your style through linters and formatter config. AI tools read a project instructions file instead. This is the single highest-leverage thing you can do on migration day: a good instructions file is the difference between an agent that writes code like your team and one that invents its own patterns.

The file differs by tool, but the content is the same — your architecture, naming rules, testing requirements, and workflow expectations.

Cursor

Cursor reads rule files from .cursor/rules/. Keep them scoped — one file per concern (architecture, testing, API conventions) so you can attach the relevant ones per task.

---
description: API route conventions
globs: ["src/pages/api/**"]
---

- API routes live in src/pages/api/ with kebab-case filenames
- Validate input with Zod at the top of every handler
- Return typed JSON: `new Response(JSON.stringify(data), { status, headers })`
- Never log request bodies (they contain PII)

Claude Code

Claude Code reads CLAUDE.md at the repo root. Consolidate everything into one coherent document.

# Project Instructions

## Architecture
- Components in src/components/ (PascalCase), API routes in src/pages/api/ (kebab-case)
- State in TanStack Query; no global stores for server data

## Conventions
- TypeScript strict mode; named exports only; `unknown` over `any`

## Workflow
- Explain the plan before editing more than one file
- Run `npm test` after every significant change
- Use conventional commit messages

Codex

Codex reads AGENTS.md at the repo root. Because Codex often runs autonomously, be more prescriptive and spell out boundaries.

# Agent Instructions

## Conventions
- TypeScript strict mode, named exports only
- Components in src/components/, API routes in src/pages/api/

## Verification
- Run `npm test` and `npm run type-check` after changes

## Boundaries
- Do not modify src/auth/ without explicit approval
- Do not edit applied database migrations or delete test files

Tip

Copy-paste prompt for scaffolding your instructions file from an existing repo:

“Analyze this repository and draft a project instructions file. Infer my conventions from the actual code, not from defaults: directory structure and naming patterns, the testing framework and how tests are organized, lint/formatter rules from the config files, the state-management and data-fetching approach, and the commit message style from git log. Output it as [a single CLAUDE.md | a single AGENTS.md | scoped files for .cursor/rules/]. Where the codebase is inconsistent, note the dominant pattern and flag the exception.”

The One Habit That Changes: Describe, Don’t Write

In a traditional IDE you implement a change line by line and lean on Find-and-Replace for the mechanical parts. The AI-first workflow inverts this: you describe the end state and the constraints, the agent proposes a coordinated multi-file diff, and your job becomes reviewing rather than typing. The skill you’re building is precise specification, not faster typing.

Take a real, recognizable task — migrating an Express route module from callback-style error handling to async/await with a shared error middleware. In the old workflow you’d open each route file, rewrite the handlers by hand, update the tests, and hope you caught every call site. In the new workflow:

Cursor

Open Agent mode with Cmd/Ctrl+I and describe the change. Cursor plans it, edits every affected file, and shows you a per-file diff to accept or reject.

Refactor src/routes/ from callback-style error handling to async/await.
Wrap each handler so thrown errors propagate to a shared
errorHandler middleware in src/middleware/error.ts (create it if it
doesn't exist). Update the matching tests in tests/routes/ and run
the suite. Show me the diff before applying.

Claude Code

Claude Code is agentic by default — it discovers the affected files itself, so you don’t need to @-mention them. Review afterward with git diff.

claude "Refactor src/routes/ from callback-style error handling to
async/await. Route thrown errors to a shared errorHandler middleware
in src/middleware/error.ts. Update tests in tests/routes/ and run
npm test. Plan the change before editing."

Codex

Hand the task to Codex and let it run in the sandbox, then review the resulting diff. Good for well-scoped refactors you can define up front.

codex "Refactor src/routes/ from callback-style error handling to
async/await, routing errors to a shared errorHandler middleware in
src/middleware/error.ts. Update tests in tests/routes/ and run
npm test to verify."

The mechanics differ, but the discipline is identical across all three tools: state the end state, name the files or directories in scope, specify how to verify (run the tests), and review the diff before trusting it.

Tip

Copy-paste prompt for a scoped, review-first refactor:

“Refactor only the files I name — do not touch anything outside this scope. Target files: [list]. Goal: [describe the end state precisely]. Constraints: keep the public API of these modules unchanged, preserve existing behavior, and update the matching tests. Before editing, give me a one-paragraph plan and the list of files you intend to change. After editing, run the test suite and summarize what changed and why.”

Note

This is also where MCP servers pay off. Connect the GitHub MCP server and the agent can open the PR for the refactor; connect a Postgres MCP server and it can verify a schema change against your actual database instead of guessing. All three tools support MCP. Cursor and Claude Code share the same mcpServers JSON config shape, so a server entry copies straight across; Codex uses a different format — [mcp_servers.<name>] tables in ~/.codex/config.toml — so you redefine each server there (or run codex mcp add).

Which Model to Reach For

Coming from an IDE where the only “model” choice was your autocomplete engine, the model picker is new. A sensible default ladder:

• Claude Fable 5 — Anthropic’s most capable model (released June 9, 2026). Reach for it on the hardest refactors, greenfield builds, and long-running tasks where velocity and quality matter more than cost. Switch in Claude Code with /model fable. Available in Cursor’s model picker and via the API. ($10/$50 per million tokens; 2× Opus 4.8.) See model comparison for plan-inclusion details.
• Claude Opus 4.8 — the Claude Code default model. Strong at complex multi-file work and agentic planning; a good everyday choice when Fable 5’s cost is a factor.
• Claude Sonnet 4.6 — the workhorse for routine edits and fast iteration when cost matters.
• GPT-5.5 — powers Codex across all surfaces by default; gpt-5.4-mini is the lower-cost option that extends your usage when you hit rate limits.
• Gemini 3.1 Pro — reach for it when you need extreme context or image/video analysis.

In Cursor the picker makes switching trivial — start with the strongest model and downgrade only when you’re cost-conscious. In Claude Code and Codex, set the model per session or in config.

Map Your Old Features to the New Ones

Most of what your IDE did still exists — it’s just driven by description instead of menus.

Traditional Feature	Cursor	Claude Code	Codex
Find & Replace	AI refactor in Agent mode	Multi-file edit from one prompt	Task-scoped multi-file edit
IntelliSense	AI completions + Tab	Inline suggestions via editor extension	IDE extension completions
Debugger	Native debugger + AI diagnosis	Native debugger + AI from terminal	Native debugger + AI in IDE
Git integration	Built-in + AI commit messages	CLI git + AI commit messages	CLI git + AI commit messages
Extensions	Open VSX compatible	Works alongside any editor	Works alongside any editor
Snippets	Generated on demand	Generated on demand	Generated on demand

Caution

Inline autocomplete is the one feature that genuinely differs. Cursor has the full Tab-completion experience you’re used to. Claude Code and Codex are agent-first — they don’t replace inline autocomplete, so if you live in completions, either keep using your editor’s completions alongside them or choose Cursor.

When This Breaks

A critical extension isn’t on Open VSX. Cursor pulls from Open VSX, so proprietary Microsoft extensions (some debuggers, Live Share, certain language packs) may be missing. Search Open VSX for an open-source equivalent, or keep your old IDE around for the one workflow that needs it. Don’t sideload Marketplace VSIX files blindly — many Microsoft extensions are licensed for Microsoft products only.

The agent ignores a convention you wrote down. Vague rules get vague compliance. Replace “use good error handling” with a concrete example block in your instructions file showing exactly the pattern you want. Specificity is what makes rules stick.

The agent over-refactors. Coming from manual editing, the biggest shock is an agent “helpfully” rewriting code you didn’t ask it to touch. Scope every prompt: name the files or directory, and add “do not change anything outside these files.” For autonomous tools, set --sandbox read-only or --ask-for-approval on-request until you trust the boundaries.

It feels slower in week one. This is real and expected. You’re trading typing speed for specification speed, and the second skill takes a couple of weeks to build. Start on a low-stakes side project or non-critical tickets, not the production hot path, while the new reflexes form.

Muscle-memory misfires. Your old keybindings may collide with AI shortcuts (Cmd/Ctrl+K, Cmd/Ctrl+I). Remap the AI commands rather than relearning your editing keys — the friction disappears once the conflicts are gone.

What’s Next

Migrating from GitHub Copilot Already on Copilot? Upgrade from inline suggestions to full agent capabilities.

Migrating from Windsurf Map Cascade and Flows to Cursor, Claude Code, and Codex.

Migrating Between Codex, Cursor, and Claude Code Cross-tool migration strategies for multi-tool teams.

Project Conversion Playbook Make any repo AI-ready with the right context and config files.