VS Code vs Cursor Remote Dev: 12-Step SSH Setup

Marcus Chen
September 15, 2026
21 min read

Remote development is where the VS Code vs Cursor debate gets uncomfortable for Cursor fans. Both editors share the same Electron shell and the same extension API, but the moment you SSH into a cloud box, spin up a dev container, or try to code from a machine with 4GB of RAM, the two editors stop behaving like siblings. This tutorial walks through setting up SSH remoting and Dev Containers in both VS Code 1.137 and Cursor 2.x side by side, flags the specific failure points teams hit in September 2026, and ends with a working project you can clone onto any remote host today.

If you already migrated from VS Code to Cursor or wired up MCP servers, this guide fills the gap those left behind: how to keep a heavy AI editor usable when your code, your Docker daemon, and sometimes your GPU live on a machine you don’t own.

Don’t miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Why Remote Development Setup Is a Different Problem Than Local Editing

Local editing tests how fast an editor opens files and autocompletes code. Remote development tests something else entirely: how well an editor tolerates network latency, how it manages a second process running on hardware it doesn’t control, and how gracefully it degrades when the connection drops mid-refactor. That’s a different engineering problem, and it’s why the vs code vs cursor comparison looks completely different once you add SSH and containers into the mix.

VS Code’s remote architecture has had roughly seven years to mature. According to the Visual Studio Code documentation: “The Visual Studio Code Remote – SSH extension allows you to open a remote folder on any remote machine, virtual machine, or container with a running SSH server and take full advantage of VS Code’s feature set.” That server-client split, where a lightweight VS Code Server binary runs on the remote host and the UI stays local, is the backbone of everything covered in this guide.

Cursor, since it’s a fork of VS Code, inherited that same architectural idea, but it rebuilt its own remote-connection layer rather than shipping Microsoft’s proprietary Remote extensions (those extensions are licensed for use only inside official VS Code builds, so forks have to reimplement them). That rebuild is exactly where the gaps show up, and where this tutorial spends most of its troubleshooting sections.

There’s also a bandwidth dimension people underestimate. A local editing session barely touches your network connection beyond the occasional extension update or Git fetch. A remote session is constantly shuttling file-change events, terminal output, and IntelliSense requests back and forth, which is why a coffee-shop Wi-Fi connection that feels fine for browsing can make a remote coding session feel sluggish. Wired ethernet or a stable 5GHz Wi-Fi connection makes a bigger practical difference to remote dev than almost any editor setting.

GitHub Codespaces and the Third Option Worth Knowing About

Before going further, it’s worth naming the option this tutorial isn’t covering: GitHub Codespaces, which spins up a fully managed container in GitHub’s cloud and lets you connecta VM or installing Docker anywhere. Codespaces uses the same devcontainer.json spec described in this guide, so everything you build in Steps 5-8 is portable to it later if you decide managed infrastructure beats self-hosted

The reason this tutorial focuses on self-managed SSH and Dev Containers instead is control and cost predictability. Codespaces bills by compute-hour and storage, which adds up fast for always-on development boxes, while a self-managed VM on a provider like Hetzner or DigitalOcean has a flat monthly cost regardless of how many hours you spend connected. If you outgrow self-managed infrastructure, the migration path to Codespaces is short precisely because the devcontainer.json format is shared across all three approaches.

Prerequisites and Versions You’ll Need

Before touching a terminal, confirm you have the following in place. Version mismatches are the single biggest cause of “it worked yesterday” remote-dev bug reports.

• VS Code 1.137 or later (current stable as of September 2026), free, MIT-licensed, no paid tier
• Cursor 2.x (latest stable build), Hobby (free), Pro ($20/month), Pro+ ($60/month), Ultra ($200/month), or a Teams plan
• Remote – SSH extension pack for VS Code (installs automatically when you connect)
• Dev Containers extension (ms-vscode-remote.remote-containers) for VS Code, or Cursor’s built-in equivalent
• An SSH-reachable remote host: a cloud VM (AWS EC2, DigitalOcean, Hetzner), a home server, or a company-issued dev box, running Linux or macOS
• OpenSSH server running on that remote host, with key-based authentication configured
• Docker Engine 27+ or Podman installed on the remote host (only needed for the Dev Containers section)
• A local machine running Windows, macOS, or Linux with an SSH client (built into all three OSes now)
• Basic familiarity with ~/.ssh/config syntax
• At least 2GB of free RAM on the remote host for the VS Code/Cursor server process itself, on top of whatever your project needs

None of this requires a GPU, a Kubernetes cluster, or a paid Cursor tier to get started, the Hobby tier and free VS Code will get you through Steps 1 through 8. You’ll only hit a wall on the AI-agent-over-SSH steps near the end if you’re on Cursor’s free plan.

Step 1: Generate and Deploy an SSH Key Pair

Both editors authenticate to the remote host the same way: standard SSH keys. There’s no editor-specific auth layer here, so get this right once and it works for both.

# On your local machine
ssh-keygen -t ed25519 -C "remote-dev-2026" -f ~/.ssh/id_ed25519_remotedev

# Copy the public key to your remote host
ssh-copy-id -i ~/.ssh/id_ed25519_remotedev.pub youruser@your-remote-host

# Test the connection
ssh -i ~/.ssh/id_ed25519_remotedev youruser@your-remote-host "echo connection ok"

If ssh-copy-id isn’t available (it’s missing by default on some Windows setups), manually append the contents of the .pub file to ~/.ssh/authorized_keys on the remote host. Confirm permissions are 700 on .ssh and 600 on authorized_keys. SSH silently refuses to use keys if the permissions are too open, and that’s a common” errors that have nothing to do with the key itself

Step 2: Configure Your SSH Config File Once for Both Editors

Both VS Code and Cursor read the same ~/.ssh/config file, so you only need to write this once. This is the biggest time-saver in the whole setup.

# ~/.ssh/config
Host remotedev
    HostName your-remote-host-ip-or-domain
    User youruser
    IdentityFile ~/.ssh/id_ed25519_remotedev
    ServerAliveInterval 60
    ServerAliveCountMax 3
    ForwardAgent yes

The ServerAliveInterval line matters more than it looks. Remote development sessions die silently when a NAT gateway or corporate firewall drops idle connections, and without a keepalive ping every 60 seconds, both VS Code and Cursor will eventually show a frozen editor with no error message. This single line prevents most of the “my remote session just stopped responding” tickets.

SSH Config Options Reference

The options above aren’t the only ones worth knowing. Here’s a quick reference for the SSH config directives that matter most for a remote development setup, since getting these wrong is responsible for most of the connection issues covered later in this guide.

Directive	Purpose	Recommended value
HostName	The actual IP address or domain of the remote machine	Your VM’s public IP or hostname
User	The Linux/macOS username to authenticate as	Your provisioned non-root user
IdentityFile	Path to the private key used for authentication	A dedicated key per purpose, not your default id_rsa
ServerAliveInterval	How often the client pings the server to keep the connection alive	60 seconds
ServerAliveCountMax	How many missed pings before the client gives up and disconnects	3
ForwardAgent	Forwards your local SSH agent so Git and other tools authenticate remotely	yes
Compression	Compresses traffic, helping on slow connections at a small CPU cost	yes, only on low-bandwidth links

Step 3: Connect VS Code to the Remote Host

Open VS Code, press Ctrl+Shift+P (or Cmd+Shift+P on macOS), and run Remote-SSH: Connect to Host. Select the remotedev alias you just created. VS Code opens a new window, downloads and installs the VS Code Server binary on the remote host automatically (this takes 20-40 seconds on the first connection), and then behaves exactly like a local window from that point forward.

According to the VS Code Remote Development overview, “Remote – SSH – Connect to any location by opening folders on a remote machine/VM using SSH.” That one-line description undersells how much is happening under the hood: your terminal, your debugger breakpoints, your linter, and your extensions are all now running server-side, while only the rendered UI travels back to your laptop.

Once connected, open your project folder with File → Open Folder, pointing at a path on the remote filesystem, not a local one. Any extensions you want available (linters, language servers, Git tooling) need to be installed in the remote window specifically. VS Code splits extensions into “Local” and “Remote” categories in the Extensions sidebar, and this trips up a lot of first-time remote users who install an extension locally and can’t figure out why it’s not doing anything.

Step 4: Connect Cursor to the Remote Host

Cursor’s remote SSH flow looks nearly identical on the surface. Open the command palette, run Remote-SSH: Connect to Host, and pick the same remotedev alias, since it’s reading the same ~/.ssh/config file. Under the hood, Cursor is not using Microsoft’s proprietary Remote-SSH extension (that extension’s license restricts it to official Microsoft builds), so Cursor ships its own reimplementation of the server-client protocol.

This is where the two editors diverge in practice, not just in licensing. Cursor’s in-house SSH implementation is newer and less battle-tested than VS Code’s, and testing has surfaced a noticeably higher rate of connection drops, stalled file syncs, and occasional 404 errors when reconnecting to an existing remote session after sleep or network changes. It generally still works for day-to-day coding, but expect to reconnect more often than you would in VS Code, especially on flaky Wi-Fi or VPN connections.

One frequently reported limitation as of September 2026: Cursor’s remote SSH sessions do not reliably combine with Dev Containers the way VS Code’s do. You can SSH into a host directly, or you can open a container locally, but chaining “SSH into a remote box, then attach to a container running on that box” is the combination most likely to fail in Cursor. Keep that in mind before you commit a team’s workflow to it.

Step 5: Set Up Docker on the Remote Host for Dev Containers

Dev Containers let you define a project’s entire toolchain (language runtime, system packages, CLI tools) in a JSON file that’s checked into your repo, so every teammate gets an identical environment. Running the Docker daemon on the remote host, rather than locally, means your laptop never needs Docker Desktop installed at all.

# On the remote host (Ubuntu/Debian example)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

# Verify Docker is running without sudo
docker run hello-world

The VS Code remote SSH documentation is explicit about this benefit: “If you are using a Linux or macOS SSH host, you can use the Remote – SSH and Dev Containers extensions together to open a folder on your remote host inside of a container.” And crucially: “You do not even need to have a Docker client installed locally.” That’s a meaningful win for anyone on a locked-down corporate laptop where installing Docker Desktop requires an IT ticket.

Step 6: Write a devcontainer.json for Your Project

Create a .devcontainer folder in your project root with a devcontainer.json file describing the environment. This file is what both VS Code and Cursor read to build the container.

{
  "name": "remote-dev-tutorial",
  "image": "mcr.microsoft.com/devcontainers/typescript-node:20",
  "features": {
    "ghcr.io/devcontainers/features/docker-in-docker:2": {}
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode"
      ]
    }
  },
  "forwardPorts": [3000],
  "postCreateCommand": "npm install",
  "remoteUser": "node"
}

Pin the base image tag (typescript-node:20, not :latest) every single time. Floating tags are the number-one reason a container that worked last Tuesday silently breaks this Tuesday when the upstream image gets rebuilt with a new Node minor version. This is true regardless of which editor opens the container, it’s a Docker best practice, not an editor quirk.

Step 7: Open the Dev Container in VS Code

With the .devcontainer folder committed, VS Code detects it automatically and shows a “Reopen in Container” prompt in the bottom-right corner. Alternatively, run the command palette action Dev Containers: Reopen in Container. VS Code builds the image (or pulls it if already built), starts the container, mounts your project folder inside it, and installs the VS Code Server inside the container itself: a nested version of the same server-client model from Step 3.

Combined with Remote-SSH from Step 3, you get a three-layer stack: your local UI, talking to a VS Code Server on the remote host, which is talking to a VS Code Server inside a container on that same remote host. According to the VS Code Remote Development FAQ, this exact chaining is supported: “The Visual Studio Code Remote Development extension pack allows you to open any folder in a container, on a remote machine (via SSH), or in the Windows Subsystem for Linux and take advantage of VS Code’s full feature set.”

Step 8: Open the Same Dev Container in Cursor

Cursor supports the same devcontainer.json spec and shows a similar “Reopen in Container” prompt when it detects the folder. Locally, opening a Dev Container in Cursor (without also SSHing into a remote host first) works reliably in most testing. The friction shows up specifically in the combined SSH-plus-container chain described in Step 4, not in local-container use alone.

If your workflow is “clone locally, open in a container” rather than “SSH to a cloud box, then open a container on it,” Cursor’s Dev Containers support is close enough to VS Code’s that the choice comes down to which editor’s AI features you prefer, not which one handles containers better. Save the SSH-plus-container combo for VS Code until Cursor’s reimplementation matures further.

Step 9: Run AI Agents Against Remote and Containerized Code

This is the step that actually matters for most people reading a vs code vs cursor comparison in 2026: can the AI features work against code that isn’t sitting on your local disk?

VS Code 1.137 ships deeper Agent window integration, letting you automate recurring work, continue chats scoped to a workspace, and work with GitHub issues and pull requests without leaving the Agents panel. This works against a remote SSH session or a Dev Container the same way it works locally, since the agent runs against whatever workspace is currently open, remote or not.

Cursor’s agent and Composer modes also operate against the currently open workspace, including remote SSH sessions, but agent responsiveness depends on your plan tier. The free Hobby tier caps Tab completions and agent requests tightly enough that heavy agent use over a laggy SSH connection becomes impractical. You’ll burn through the daily quota fast when every agent call also has to round-trip through the remote connection. Pro ($20/month) or higher, per Cursor’s pricing page, removes those caps and is the realistic minimum for doing serious remote AI-assisted work in Cursor.

Step 10: Configure Port Forwarding for Remote Web Apps

If your remote project runs a local dev server (a React app on port 3000, an API on port 8000), you need port forwarding to view it in a browser on your laptop. Both editors handle this through the same “Ports” panel, typically docked next to the terminal.

# Inside the remote/container terminal, start your dev server as usual
npm run dev

# In the editor's Ports panel, click "Forward a Port" and enter 3000
# Or forward it manually via SSH if you prefer the CLI:
ssh -L 3000:localhost:3000 remotedev

Both VS Code and Cursor auto-detect commonly used ports (3000, 5173, 8080) and offer to forward them the moment a process starts listening. If auto-detection doesn’t fire, forward the port manually using the panel. It’s more reliable than waiting for detection, especially inside a Dev Container where the detection logic has one more network layer to see through.

Step 11: Handle Git Credentials Across the Remote Boundary

A subtle but common failure: Git commands work fine locally, then fail with authentication errors the moment you’re inside a remote SSH session or container, because your local Git credential helper and SSH agent don’t automatically travel with you.

The fix is SSH agent forwarding, which the ForwardAgent yes line from Step 2 already enables. Verify it’s working with:

# Inside the remote SSH session terminal (in the editor, not a separate SSH client)
ssh-add -l
# Should list your local SSH keys, forwarded from your laptop

# Test Git access using the forwarded agent
git clone [email protected]:youruser/your-private-repo.git

Inside a Dev Container, agent forwarding needs one extra step: the container needs to mount the forwarded SSH agent socket. Both VS Code and Cursor do this automatically for Dev Containers when agent forwarding is already active on the underlying SSH connection, but it silently fails if ForwardAgent isn’t set at the SSH config level first. That’s another reason Step 2 isn’t optional.

Step 12: Add Team Governance for Shared Remote Environments

If multiple engineers share the same remote dev boxes or a Teams-tier Cursor account, governance stops being optional. Cursor’s Teams Standard plan runs $40 per user per month, and Teams Premium runs $120 per user per month, with Premium adding roughly 5x the included usage pool plus organization-wide privacy modes and centralized billing. VS Code has no equivalent paid team tier. Team governance for VS Code remote setups is handled entirely through GitHub org permissions, SSH key management, and infrastructure-level access controls (IAM roles on the cloud VM, for instance) rather than through the editor itself.

That’s the real trade-off buried in this comparison: VS Code pushes governance to your infrastructure team, while Cursor bundles governance (SSO, RBAC, usage analytics, org-wide privacy settings) directly into a paid subscription. Neither is objectively better. It depends on whether your organization already has strong infra-level access controls or would rather pay per seat for built-in governance.

Security Considerations for Remote and Containerized Development

Opening your codebase to a remote machine changes your threat model, and it’s worth being deliberate about it rather than treating it as a pure convenience upgrade. The biggest exposure is the SSH key itself: a dedicated key scoped only to remote-dev boxes (as set up in Step 1) means that if your laptop is ever compromised, an attacker gains access to your dev infrastructure specifically, not every server you’ve ever touched with a shared key.

Disable password authentication entirely on the remote host’s SSH daemon (set PasswordAuthentication no in /etc/ssh/sshd_config) once your key-based login is confirmed working. Automated scanners probe port 22 on public IPs constantly, and disabling password auth removes brute-force login as a viable attack path outright.

Inside Dev Containers, avoid running as root unless a tool genuinely requires it. The remoteUser field in devcontainer.json from Step 6 exists specifically so your container processes run as an unprivileged user by default. Docker-in-Docker setups (used for CI-style workflows inside a container) also widen the attack surface, since a compromised process with Docker socket access can affect the host, not just the container. Only enable that feature when you actually need to build images from inside the container itself.

For teams using Cursor’s cloud agent features against remote codebases, check the org-wide privacy mode setting on Teams plans before rolling it out, Cursor’s privacy mode controls whether code snippets sent to underlying AI models are retained for training, and this is a governance decision that should be made deliberately at the org level, not left to individual defaults.

VS Code vs Cursor Remote Development: Feature Comparison

Feature	VS Code 1.137	Cursor 2.x
Remote SSH support	Mature, Microsoft-maintained extension	In-house reimplementation, higher connection-drop reports
Dev Containers	Full support, including SSH + container chaining	Local containers work well, SSH + container chaining is unreliable
Cost for remote dev	Free, no tier restrictions	Free (Hobby) to $200/month (Ultra) depending on AI usage needed
Live collaborative editing	Supported via Live Share extension	Not supported
AI agent access while remote	Agents window works against remote/container workspace	Composer/Agent works remotely, capped hard on free tier
Team governance features	None built-in, relies on GitHub org + infra IAM	SSO, RBAC, usage analytics on Teams plans ($40-$120/user/month)
Docker required locally	No (only needs to run on the remote host)	No (same model, Docker runs remotely)

Cursor Pricing Tiers for Remote AI Workflows

Plan	Price	Best for remote dev use case
Hobby	Free, no card required	Light remote SSH editing, minimal agent calls
Pro	$20/month (~$16/month annual)	Daily remote work with regular agent use
Pro+	$60/month	Heavy agent usage across large remote codebases
Ultra	$200/month	Continuous agent-driven remote workflows at scale
Teams Standard	$40/user/month	Small teams sharing remote infrastructure
Teams Premium	$120/user/month	Larger orgs needing SSO, RBAC, and shared cloud agents

Common Pitfalls When Setting Up Remote Development

• Forgetting ForwardAgent yes, Git operations inside the remote session fail with authentication errors even though local Git works fine.
• Using floating image tags in devcontainer.json. A container that built cleanly last week fails today because :latest pulled a new image with a breaking change.
• Installing extensions locally instead of in the remote window. VS Code and Cursor both separate local and remote extension installs, and installing in the wrong scope means the extension silently does nothing.
• Chaining SSH and Dev Containers in Cursor. This specific combination is the least reliable path in Cursor’s current remote implementation. Test it before committing a team workflow to it.
• Skipping ServerAliveInterval in the SSH config. Idle connections get dropped by NAT gateways or corporate firewalls, and the editor freezes with no visible error.
• Running Cursor’s agent heavily on the Hobby tier over SSH. You’ll exhaust the free quota fast, since each agent call round-trips through the remote connection on top of the usual request cost.
• Not pinning the remote user in devcontainer.json. Files created inside the container end up owned by root, causing permission errors when you try to edit them from outside the container later.
• Forgetting Docker group membership on the remote host. Commands work with sudo docker but fail with a permissions error under the editor’s non-root exec, because the group change from usermod -aG docker didn’t take effect until a fresh login shell.

Expected Output at Each Milestone

Here’s what a successful setup looks like at three checkpoints, so you know you’re on track before moving further.

# After Step 3/4 (SSH connection established)
# Bottom-left corner of the editor window shows:
>< SSH: remotedev

# After Step 7/8 (Dev Container attached)
# Bottom-left corner shows:
Dev Container: remote-dev-tutorial

# After Step 9 (agent working against remote code)
# Terminal output from a successful npm install triggered by postCreateCommand:
added 214 packages, and audited 215 packages in 8s
found 0 vulnerabilities

Building a Complete Working Project: Remote Node API in a Dev Container

Put the whole setup together with a minimal but complete project: a Node.js API running inside a Dev Container on a remote host, editable from either VS Code or Cursor.

# Project structure
remote-api-demo/
├── .devcontainer/
│   └── devcontainer.json
├── src/
│   └── index.js
├── package.json
└── .gitignore

// src/index.js
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    message: 'Running inside a remote dev container',
    editor: process.env.EDITOR_NAME || 'unknown',
    timestamp: new Date().toISOString()
  }));
});

server.listen(3000, () => console.log('Listening on port 3000'));

{
  "name": "remote-api-demo",
  "version": "1.0.0",
  "main": "src/index.js",
  "scripts": {
    "dev": "node src/index.js"
  }
}

Clone this onto your remote host, open it, reopen in the container (Step 7 or Step 8), run npm run dev in the integrated terminal, forward port 3000 (Step 10), and open localhost:3000 in your local browser. You should see the JSON response confirming the server is running remotely, inside a container, edited from your local editor UI. That end-to-end chain is the entire point of this tutorial

Troubleshooting Common Remote Development Errors

• “Permission denied (publickey)”. Check .ssh folder permissions are 700 and authorized_keys is 600 on the remote host, since overly permissive folders cause SSH to silently reject the key.
• Connection hangs at “Downloading VS Code Server”. The remote host likely can’t reach Microsoft’s download CDN. Check outbound firewall rules or proxy settings on the remote host.
• Cursor shows a 404 when reconnecting to a previous remote session. This is a known reliability gap in Cursor’s SSH reimplementation. Disconnect fully and reconnect fresh rather than trying to resume the stale session.
• Dev Container build fails with “no space left on device”. Docker images and build layers accumulate on the remote host. Run docker system prune -a to reclaim space.
• Git push fails with “Could not read from remote repository” inside the container. Confirm ssh-add -l shows your key inside the remote/container terminal. If empty, ForwardAgent yes isn’t taking effect, often because of a typo in the SSH config Host alias.
• Extensions installed but not activating in the remote window. Reinstall them specifically from the remote Extensions panel, since a local-only install won’t activate against a remote or containerized workspace.
• Port forwarding shows “connection refused” in the browser. Confirm the dev server inside the container is bound to 0.0.0.0, not 127.0.0.1. Binding to localhost inside a container makes it unreachable from outside the container network namespace.
• Agent/Composer requests time out constantly over SSH in Cursor. This compounds normal network latency with the AI request round-trip. If it’s unworkable, edit locally and sync via Dev Containers running against a local Docker daemon instead of full remote SSH.

Advanced Tips for Production-Grade Remote Setups

Once the basic setup is stable, a few refinements make remote development genuinely pleasant rather than just functional.

Pre-build your Dev Container images in CI and push them to a registry, rather than building from scratch on every “Reopen in Container.” A pre-built image cuts container startup from minutes to seconds, which matters a lot when you’re rebuilding several times a day during active development. Reference the pre-built image directly in devcontainer.json instead of a Dockerfile build context.

Use a devcontainer.json features block instead of hand-rolled Dockerfile RUN commands wherever possible. The official devcontainer features registry maintains versioned, tested installers for common tools (Node, Python, Rust, Docker-in-Docker), and they’re far less brittle than shell scripts you write yourself.

For teams standardizing on Cursor for remote work despite the SSH-plus-container limitation, the practical workaround is to run Dev Containers locally against Docker Desktop or Colima, while keeping only the heaviest compute (training jobs, large builds) on remote infrastructure accessedconnection. It’s a compromise, but it sidesteps the specific failure mode until Cursor’s remote implementation catches up

If your remote host is shared across a team, set resource limits in devcontainer.json (hostRequirements with cpus and memory fields) so one engineer’s runaway build process doesn’t starve everyone else’s editor session on the same box.

Consider splitting your remote infrastructure by workload type rather than running everything on one box. A small always-on VM (2-4 vCPUs) is enough for day-to-day editing, linting, and running a dev server, while genuinely heavy jobs (full test suites, large builds, model training) belong on a separate, larger instance you spin up on demand and tear down when finished. This keeps your everyday remote-dev bill low while still giving you burst capacity when you need it, and it means a runaway process during a big job can’t freeze the editor session you use for everything else.

Finally, snapshot your remote host’s disk periodically if it holds anything not backed up in Git, such as build caches, local databases, or environment files. Cloud providers charge little for periodic snapshots relative to the cost of rebuilding a dev environment from scratch after an accidental `rm -rf` or a host that fails to boot.

When to Choose VS Code and When to Choose Cursor for Remote Work

If your team’s daily workflow depends on SSHing into shared infrastructure and layering Dev Containers on top of that connection, VS Code’s remote stack is the safer default in September 2026. It’s the more mature, more predictable path, and it costs nothing. If your priority is Cursor’s specific AI agent behavior and your remote needs are lighter (a straightforward SSH session, or a locally-run Dev Container), Cursor works fine and the reliability gap won’t affect you day to day.

Budget matters too. A solo developer on Cursor’s free Hobby tier doing occasional remote edits won’t notice much difference from VS Code. A team running agent-heavy workflows against shared remote infrastructure needs to budget for Pro+ or Ultra just to avoid hitting usage caps mid-task, on top of whatever the remote infrastructure itself costs: a real expense VS Code’s all-free model simply doesn’t add.

There’s also a middle path worth considering: running VS Code for the remote SSH and Dev Container work specifically, while keeping Cursor open in a second window for local AI-assisted editing on files that don’t need to touch the remote host. It’s an extra window to manage, but it sidesteps the SSH-plus-container reliability gap entirely while still giving you access to Cursor’s agent features for the parts of your work that don’t depend on remote infrastructure.

Frequently Asked Questions

Is Cursor’s free Hobby tier enough for daily remote SSH development?

It’s workable for light editing, but agent and Tab completion limits are tight enough that anyone doing regular AI-assisted work over a remote connection will hit the caps quickly. Pro at $20/month removes that ceiling.

Can I combine SSH remote development with Dev Containers in Cursor?

Technically yes, but it’s the least reliable combination in Cursor’s current implementation. VS Code handles this chaining more consistently. If you need both together for a team workflow, VS Code is the safer choice today.

Do I need Docker installed on my laptop for Dev Containers?

No, in either editor. As long as Docker runs on the remote host you’re SSHing into, the container builds and runs there. Your local machine never touches Docker.

Why does Git fail inside my remote session even though it works locally?

Almost always missing SSH agent forwarding. Add ForwardAgent yes to your SSH config Host block and confirm it’s active with ssh-add -l inside the remote terminal.

Does VS Code Live Share work in Cursor?

No. Live Share’s real-time collaborative editing, shared terminals, and shared debugging are not available in Cursor as of September 2026.

Which is cheaper for a small team doing remote development: VS Code or Cursor?

VS Code is free regardless of team size. Cursor’s Teams Standard plan runs $40 per user per month, and Teams Premium runs $120 per user per month, so a 5-person team pays $200-$600/month on top of infrastructure costs: a real budget line VS Code doesn’t add.

What’s the minimum remote host spec for running either editor’s server component?

Budget at least 2GB of free RAM specifically for the editor server process, separate from whatever your actual project needs to run. Under-provisioned hosts show up as a sluggish, laggy editor experience that’s easy to mistake for a network problem.

Can I use the same devcontainer.json file for both VS Code and Cursor?

Yes. Both editors implement the same open devcontainer.json specification maintained at containers.dev, so one config file works for both without modification.