Cursor vs VS Code: What Changes and What Stays

If you have been using Visual Studio Code, learning Cursor does not mean starting over. Almost everything you know transfers directly. The file structure, the extensions, the keyboard shortcuts, the terminal: it all works the same way. What Cursor adds is a set of AI features built deeply into the editor.

This lesson draws a clear line between what stays the same and what changes, introduces each of Cursor's core AI features, and helps you decide when to reach for Cursor versus when VS Code might still be the right tool.

What You'll Learn

• Why Cursor and VS Code feel so similar (the fork relationship explained)
• Everything that carries over from VS Code without any changes
• The AI features Cursor adds: Tab, Cmd+K, the Agent side panel and its modes, @-mentions, and the Agents Window
• What is different in Cursor's settings compared to VS Code
• The model picker and how Cursor lets you choose your AI
• When to use Cursor and when to stick with VS Code
• Whether you can run both side by side on the same machine

---

Why Cursor Feels Like VS Code

Cursor is a fork of VS Code. In software terms, a fork means that the Cursor team took the VS Code source code as a starting point and built their product on top of it. They continue to merge updates from VS Code over time, so Cursor keeps up with VS Code's improvements.

The practical result is that Cursor and VS Code share the same foundation: the same editor engine, the same extension API, the same settings format, and the same keyboard shortcut system. If you can do something in VS Code, you can almost certainly do it the same way in Cursor.

This is what makes Cursor's settings import so effective. There is no translation layer. Your VS Code settings work in Cursor without modification.

Extensions

VS Code extensions work in Cursor because Cursor uses the same extension API. Most extensions install and run without any changes. There are occasional exceptions, typically extensions tied closely to Microsoft services or to other AI assistants (like GitHub Copilot), but the vast majority of the ecosystem just works.

You can install extensions in Cursor the same way you would in VS Code: through the Extensions view, with the Command Palette, or from a .vsix file. Cursor uses an open extension registry rather than Microsoft's own marketplace, so on rare occasions an extension may be missing or a version behind.

Keybindings

Your everyday VS Code shortcuts work in Cursor. Ctrl+P to open files, Ctrl+Shift+P for the Command Palette, Ctrl+` for the terminal, F12 for Go to Definition: all of it is the same.

Cursor adds new shortcuts for its AI features (covered below). A few of these, like Cmd+K, Cmd+I, and Cmd+L, take over keys that do something else in plain VS Code, so you may notice small differences if you relied on those.

Themes

Your color theme, file icon theme, and product icon theme all carry over. If you have been using a popular theme like One Dark Pro, Dracula, or Nord in VS Code, it will look the same in Cursor.

Settings

The settings system is the same. settings.json works the same way, and the Settings UI has the same layout and options for all VS Code settings. The addition is a separate Cursor Settings page for AI configuration (discussed below).

---

What Cursor Adds: The AI Feature Set

Here is where the two editors diverge. Cursor builds AI into every layer of the editor, from single keystrokes to agents that work for minutes at a time.

Tab (Inline AI Completion)

Tab is Cursor's inline code completion system, powered by Cursor's own Tab model. As you type, Cursor looks at the surrounding code and your recent edits and suggests a change in grey text. Press Tab to accept it, Escape to dismiss it, or just keep typing to let it update. Cmd+→ (Ctrl+→ on Windows/Linux) accepts one word at a time.

This goes much further than VS Code's built-in IntelliSense. IntelliSense completes individual tokens based on what it knows about your types and APIs. Tab predicts whole blocks and multi-line edits based on what you are doing. It can fill in the body of a function, complete a repetitive pattern, or suggest the next logical edit, even a few lines away from your cursor.

For example, if you write three similar test cases in a row, Tab will notice the pattern and offer to complete the fourth in the same structure. If you have just defined a TypeScript interface and start writing a function that takes it as a parameter, Tab will anticipate the implementation and fill it in.

You can turn Tab on or off in Cursor Settings.

Cmd+K (Inline AI Edit)

Press Cmd+K on Mac or Ctrl+K on Windows/Linux while your cursor is in the editor, and a small inline prompt bar appears. Type a natural language instruction and press Return. Cursor generates the change directly in the file, showing a diff of what it proposes to add, remove, or modify.

This is useful for targeted edits where you do not need a full conversation. Some examples:

• Select a function and press Cmd+K, then type "add error handling for null inputs"
• Place the cursor on an empty line and press Cmd+K, then type "write a function to debounce an event handler"
• Select a block of CSS and press Cmd+K, then type "convert this to use CSS variables"

After Cursor generates the change, you review it as a diff and accept or reject it. If you want a different version, you can type a follow-up instruction in the same prompt bar.

The Agent Side Panel (Cmd+I or Cmd+L)

The Agent side panel is where you have full conversations with the AI and hand it larger tasks. Toggle it with Cmd+I or Cmd+L on Mac (Ctrl+I or Ctrl+L on Windows/Linux). It appears on the side of the editor.

The panel is code-aware. The AI can search your codebase on its own, read files, make changes across many files, and run terminal commands when you allow it. You can have long, multi-turn conversations, and you can type a follow-up while the agent is still working to queue it up.

The panel has several modes. Cycle through them with Shift+Tab in the chat input, or open the mode menu with Cmd+. (Ctrl+.):

• Agent (the default): reads and edits files, runs commands, and works through multi-step tasks until they are done
• Ask: read-only. It answers questions and explores code but does not change anything
• Plan: researches your codebase, asks clarifying questions, and writes an editable plan before any code is written. You review the plan, then have the agent build from it

There is also a Debug mode for tracking down tricky bugs, which you will meet later in the course.

Common interactions in the panel include:

• Asking the AI to explain code (Ask mode): "What does this reducer do?"
• Requesting a feature (Agent mode): "Add pagination to this list component"
• Planning a bigger change (Plan mode): "Plan how we would move authentication to a separate service"
• Getting help with debugging: "This function returns undefined when the array is empty. Why?"

When the agent changes code, you see the diffs in the editor and can accept or reject them. Checkpoints in the chat timeline also let you roll files back to an earlier point.

@-Mentions: Bringing Context Into the Conversation

You do not always need to tell the agent where to look. If you are not sure which files matter, just ask, and the agent will search the codebase itself. When you already know the relevant files, the @ symbol lets you point straight at them. Typing @ in the chat input opens a picker for things like:

• Files and folders: for example @users.ts or @src/api/, so the AI reads them directly
• @Terminals: bring in terminal output, such as an error from a failing command
• @Chats: reference an earlier conversation
• @Commit: your current uncommitted changes
• @Branch: how your branch differs from main
• @Browser: let the agent use a browser to check a page

For example, you might type: "Looking at @users.ts and @user.ts in src/types, why might createUser fail when email is undefined?"

This gives the AI exactly the context it needs without you pasting large blocks of code. When the agent needs documentation or current information, it can search the web and fetch docs on its own.

The Agents Window

Beyond the editor, Cursor has an Agents Window for running several agents in parallel. Each agent can work locally, in its own git worktree, or in the cloud, and you review what each one did before keeping it. Cloud Agents can even finish a task and return a pull request while your laptop is closed. This is the part of Cursor that most resembles terminal and cloud agent tools: AI that does whole pieces of work rather than just answering questions.

---

What Is Different in Cursor's Settings

Cursor has its own Cursor Settings page, separate from the standard VS Code settings. Open it from the gear icon or by searching the Command Palette for "Cursor Settings". It covers areas like:

• Models: which models appear in the picker
• Rules: your personal User Rules that apply to every project
• Tab: turn Tab completion on or off and adjust its behavior
• Agent: how the agent handles terminal commands, such as requiring approval or allowing trusted commands
• Privacy: whether Privacy Mode is on, so your code is not stored or used for training
• Indexing: how Cursor indexes your codebase for search

Newer versions also have a Customize page that gathers plugins, skills, MCP servers, rules, commands, and hooks in one place. The standard VS Code settings are still available through Cmd+Shift+P > Open Settings and look the same as in VS Code.

The Model Picker

The chat input has a model picker for choosing which AI model handles a conversation. Cmd+/ cycles through models. You can pick:

• Auto, which lets Cursor choose a model for each request. You can tune it toward intelligence, balance, or cost.
• Cursor's own models, such as Composer, which is built for fast agentic coding and comes with more included usage
• Models from other providers, including Anthropic's Claude models, OpenAI's GPT models, and Google's Gemini models

The exact list changes often as new models are released. Different models have different strengths. Some are faster; others are more careful but slower or more expensive. As you build experience, you will develop preferences for which model suits which task.

---

Side-by-Side Comparison

Feature	VS Code	Cursor
Extensions	Microsoft marketplace	Same extension API, open registry
Keybindings	All standard shortcuts	Same, plus AI shortcuts
Themes	All available	Same
Settings format	settings.json	Same settings.json + Cursor Settings
Inline completion	IntelliSense, or AI via GitHub Copilot	Tab (multi-line AI, built in)
Inline AI edit	Via GitHub Copilot	Cmd+K (built in)
AI chat and agent	Via GitHub Copilot	Agent side panel with Agent, Ask, and Plan modes
@-mentions	Via GitHub Copilot	Files, folders, terminals, chats, commits, branches, browser
Parallel and cloud agents	Limited	Agents Window, Cloud Agents
Model choice	Via GitHub Copilot	Built-in picker with Auto
Price	Free (Copilot has its own plans)	Free tier + paid plans

---

When to Use Cursor vs VS Code

VS Code itself has added a lot of AI through GitHub Copilot, so the gap is smaller than it once was. The difference is that Cursor is built around AI from the ground up, with its own models, Tab, Plan mode, and parallel agents.

Reach for Cursor when:

• You are writing new code and want strong AI completion and generation
• You are debugging a problem and want to have a conversation about it
• You are implementing a feature and want the agent to handle multi-step changes
• You want to plan a large change before any code is written
• You want to explore an unfamiliar codebase quickly
• You want to run several agents in parallel or hand work to the cloud

You might stick with VS Code when:

• Your organization has not approved AI tools that send code to external servers
• You need a fully offline environment
• Your team has standardized on VS Code with GitHub Copilot
• A specific extension is missing from Cursor's registry or behaves differently there

In practice, most developers who switch to Cursor use it as their primary editor. The VS Code compatibility is close enough that most workflows transfer without friction.

---

Can You Run Cursor and VS Code Side by Side?

Yes. Cursor and VS Code are separate applications that install to different places and run independently. You can have both open at the same time on the same project, or use different editors for different projects.

A few things to keep in mind:

• Extensions are separate: extensions installed in VS Code are not automatically installed in Cursor, and vice versa. The import on first launch handles your existing set, but later installs happen only in the editor you use.
• Settings are stored separately: changes in one editor do not carry over to the other. If you want a change in both, make it in both.
• Git and files are shared: both editors just read and write files, so there is no conflict at the filesystem level. You can switch between them freely for the same project.

Some developers keep VS Code installed as a fallback while using Cursor as their main editor.

---

Key Takeaways

• Cursor is a fork of VS Code, so your extensions, keybindings, themes, and settings carry over
• Cursor adds Tab (inline AI completion), Cmd+K (inline AI edit), the Agent side panel (toggled with Cmd/Ctrl+I or Cmd/Ctrl+L), and the Agents Window for parallel and cloud agents
• The side panel has Agent (default, edits and runs commands), Ask (read-only), and Plan (plan first, then build) modes; Shift+Tab switches between them
• The agent searches your codebase on its own; use @ to point at files, folders, terminals, past chats, commits, or branches when you already know what matters
• Cursor Settings is a separate page for AI configuration: models, rules, Tab, agent behavior, privacy, and indexing
• The model picker offers Auto, Cursor's own Composer models, and models from Anthropic, OpenAI, Google, and others
• You can run Cursor and VS Code side by side; they are independent applications