Skip to main content
InfraGap.com Logo
Home
Getting Started
Core Concept What is a CDE? How It Works Benefits CDE Assessment Getting Started Guide Inner Loop vs Outer Loop Environment Drift Local vs Cloud CDEs for Startups
AI & Automation
AI Coding Assistants Agentic AI AI-Native IDEs Agentic Engineering AI Agent Orchestration AI Governance AI-Assisted Architecture Shift-Left AI LLMOps Autonomous Development AI/ML Workloads CDEs for Data Science GPU Computing
Agent Infrastructure
Agent Experience (AX) Agent Egress Control Computer Use Agents Agent Evals Agent Runbooks Agent Client Protocol AGENTS.md MCP Servers Git Worktrees Kubernetes Agent Sandbox Agent Fleets Agent Identity Prompt Injection Defense Agent Observability Context Engineering AI Code Review Bottleneck Headless Agents in CI Spec-Driven Development Agent Readiness Code Provenance
Implementation
Architecture Patterns DevContainers Advanced DevContainers Language Quickstarts IDE Integration CI/CD Integration Platform Engineering Developer Portals Container Registry Multi-CDE Strategies Remote Dev Protocols Nix Environments Hermetic Builds OpenTofu for CDEs Kubernetes Development
Operations
Performance Optimization High Availability & DR Disaster Recovery Monitoring Capacity Planning Multi-Cluster Development Troubleshooting Runbooks Ephemeral Environments Sandbox Environments Workspace Snapshots Database Branching
Security
Security Deep Dive Zero Trust Architecture Secrets Management Vulnerability Management Network Security IAM Guide Supply Chain Security Air-Gapped Environments AI Agent Security MicroVM Isolation Compliance Guide EU AI Act Cyber Resilience Act Data Residency Governance
Planning
Pilot Program Design Stakeholder Communication Risk Management Migration Guide Cost Analysis FinOps GreenOps Vendor Evaluation Training Resources Developer Onboarding Team Structure Platform Maturity Model Open Source CDEs AI Productivity Paradox Build vs Buy DevEx Metrics Productivity Engineering Industry Guides CDEs for Healthcare CDEs for Financial Services CDEs for Government Edge Development WebAssembly in CDEs
Resources
Tools Comparison State of CDEs 2026 Isolation Decision Tool Template Library
Learning Paths
All Paths Platform Engineer Security and Compliance Engineering Manager
Vendor Reviews
GitHub Codespaces Coder Ona Google Workstations Microsoft Dev Box Okteto Eclipse Che DevPod Daytona E2B
Head to Head
Coder vs Codespaces Coder vs Ona Ona vs Codespaces Coder vs Okteto Self-Hosted vs Managed E2B vs Daytona CDE Market Guide CDE vs Alternatives Case Studies Lessons Learned Glossary FAQ Sources & Citations

IDE Integration Deep Dive

Advanced configuration guides for VS Code Remote SSH, JetBrains Gateway, Zed, Cursor, Windsurf, Neovim, and terminal-based workflows in Cloud Development Environments.

AI-native editors: Cursor, Windsurf (continued by Cognition as Devin Desktop), and Zed build intelligent completions, autonomous multi-file editing, and codebase-wide context into the editor itself rather than bolting them on as extensions. The Agent Client Protocol goes a step further and decouples the agent from the editor entirely, which is what makes an agent portable into a centralized workspace.

VS Code Remote SSH

Optimized configuration for seamless remote development

SSH Configuration (~/.ssh/config)

# CDE Workspace - Optimized for VS Code
Host cde-workspace
    HostName your-cde.company.com
    User developer
    Port 22

    # Performance optimizations
    Compression yes
    ServerAliveInterval 60
    ServerAliveCountMax 3

    # Faster connection multiplexing
    ControlMaster auto
    ControlPath ~/.ssh/sockets/%r@%h-%p
    ControlPersist 600

    # VS Code specific
    ForwardAgent yes
    AddKeysToAgent yes
    IdentityFile ~/.ssh/cde_key

    # Disable strict host checking for dynamic IPs
    StrictHostKeyChecking no
    UserKnownHostsFile /dev/null
    LogLevel ERROR

Note: Create the sockets directory: mkdir -p ~/.ssh/sockets

VS Code Settings (settings.json)

{
  // Remote SSH optimizations
  "remote.SSH.remotePlatform": {
    "cde-workspace": "linux"
  },
  "remote.SSH.connectTimeout": 60,
  "remote.SSH.showLoginTerminal": true,
  "remote.SSH.useLocalServer": false,

  // Performance settings
  "remote.SSH.localServerDownload": "off",
  "remote.SSH.remoteServerListenOnSocket": true,

  // File watcher optimization
  "files.watcherExclude": {
    "**/node_modules/**": true,
    "**/.git/objects/**": true,
    "**/vendor/**": true
  },

  // Search optimization
  "search.exclude": {
    "**/node_modules": true,
    "**/dist": true
  },

  // Extension sync
  "remote.SSH.defaultExtensions": [
    "ms-python.python",
    "esbenp.prettier-vscode",
    "dbaeumer.vscode-eslint"
  ]
}

Recommended Extensions for Remote Development

Remote - SSH

Core extension for remote development

Remote Explorer

Manage multiple remote connections

Settings Sync

Sync settings across workspaces

JetBrains Gateway

IntelliJ IDEA, PyCharm, WebStorm, and GoLand remote configuration

Initial Gateway Setup

Step 1: Install Gateway

  1. 1.Download JetBrains Gateway from jetbrains.com/gateway
  2. 2.Install and launch Gateway
  3. 3.Sign in with your JetBrains account
  4. 4.Select "SSH Connection" from the menu

Step 2: Configure Connection

  1. 1.Enter CDE hostname and username
  2. 2.Select SSH key authentication
  3. 3.Choose project path on remote
  4. 4.Select IDE (IntelliJ, PyCharm, etc.)

Performance Tuning

# ~/.config/JetBrains/RemoteDev/options/other.xml
# Add these VM options for better performance:

-Xmx4096m                    # Increase heap for large projects
-XX:+UseG1GC                 # Use G1 garbage collector
-XX:MaxGCPauseMillis=200     # Limit GC pauses

# Network optimizations (on CDE server)
# Add to /etc/sysctl.conf:
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# Indexing exclusions (idea.properties)
idea.max.intellisense.filesize=2500
idea.max.content.load.filesize=20000

Coder Gateway Plugin

If using Coder, install the official Gateway plugin for seamless workspace connection:

# Install Coder CLI
curl -L https://coder.com/install.sh | sh

# Configure Gateway plugin
# Gateway > Settings > Plugins > Search "Coder"
# Or install from: plugins.jetbrains.com/plugin/19620-coder

Gateway is not Fleet - do not confuse the two

JetBrains Fleet is discontinued. Downloads ended 12-22-2025 and it never left preview. JetBrains replaced it with Air, described as an agentic development environment, which at the time of writing is macOS-only and in preview.

Gateway is a separate product with a separate purpose: it is the thin client that connects a local JetBrains UI to a full IDE backend running on a remote host. Fleet's discontinuation says nothing about Gateway one way or the other. Before you standardize a team on any remote JetBrains workflow, check the current product status on JetBrains' own site rather than trusting a secondary roundup.

JetBrains and the Agent Client Protocol

JetBrains committed to the Agent Client Protocol across its IDE suite. ACP was created by Zed, released in August 2025 under Apache 2.0, and is JSON-RPC over stdio - the editor-to-agent counterpart to MCP's agent-to-tool role. Zed and JetBrains co-launched the ACP Registry on 01-28-2026. For CDE work this matters more than any single editor feature: an ACP agent runs as a process inside the remote workspace, so it sits behind your egress rules and never needs the developer's laptop to reach a model provider.

Neovim & Vim Configuration

Terminal-based development with full LSP support

Neovim LSP Setup for Remote

-- init.lua for remote development

-- Lazy.nvim plugin manager
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  -- LSP Support
  "neovim/nvim-lspconfig",
  "williamboman/mason.nvim",
  "williamboman/mason-lspconfig.nvim",

  -- Autocompletion
  "hrsh7th/nvim-cmp",
  "hrsh7th/cmp-nvim-lsp",
  "L3MON4D3/LuaSnip",

  -- Fuzzy finder
  "nvim-telescope/telescope.nvim",
  "nvim-lua/plenary.nvim",

  -- File explorer
  "nvim-tree/nvim-tree.lua",
})

-- Mason setup for LSP servers
require("mason").setup()
require("mason-lspconfig").setup({
  ensure_installed = {
    "lua_ls", "pyright", "ts_ls",
    "gopls", "rust_analyzer"
  }
})

Tmux Configuration for CDE

# ~/.tmux.conf optimized for remote

# Enable mouse support
set -g mouse on

# Increase scrollback buffer
set -g history-limit 50000

# Faster key repetition
set -s escape-time 0

# Activity monitoring
setw -g monitor-activity on
set -g visual-activity on

# Status bar with CDE info
set -g status-right '#[fg=green]#(hostname) #[fg=yellow]%H:%M'

# Resurrect sessions on reconnect
# (Install tmux-resurrect plugin)
set -g @resurrect-capture-pane-contents 'on'
set -g @continuum-restore 'on'

# Vi mode for copy
setw -g mode-keys vi
bind-key -T copy-mode-vi v send -X begin-selection
bind-key -T copy-mode-vi y send -X copy-selection

# Easy window navigation
bind -n M-h select-pane -L
bind -n M-j select-pane -D
bind -n M-k select-pane -U
bind -n M-l select-pane -R

Zed Editor

High-performance, Rust-based editor with native CDE support

Why Zed for CDEs

Zed is a Rust-based, open-source editor with GPU-accelerated rendering, native DevContainer support, built-in AI integration, and multiplayer editing. It is built for the performance demands of remote and cloud development, and its client-side footprint is small enough that remote sessions stay responsive over high-latency links.

  • Created ACP - Zed authored the Agent Client Protocol and hosts external agents such as Claude Agent and Codex CLI rather than pushing its own
  • Native DevContainers - Built in, no extensions needed
  • Free Personal tier - Unlimited edit predictions when you bring your own API key or external agent; Pro $10/month, Business $30 per seat per month (July 2026)
  • Multiplayer editing - Real-time collaboration on shared CDE workspaces

Remote Development Setup

// ~/.config/zed/settings.json
{
  // Remote development
  "remote_server": {
    "ssh": {
      "host": "your-cde.company.com",
      "user": "developer",
      "port": 22
    }
  },

  // AI assistant configuration
  "assistant": {
    "enabled": true,
    "default_model": {
      "provider": "zed.dev",
      "model": "claude-sonnet"
    }
  },

  // Performance for remote
  "buffer_font_size": 14,
  "autosave": "on_focus_change",
  "file_scan_exclusions": [
    "**/.git", "**/node_modules",
    "**/target", "**/dist"
  ]
}

Cursor

AI-native IDE built on VS Code with deep intelligence

Why Cursor for CDEs

Cursor is a VS Code fork with deep AI integration. Features include codebase-aware completions, multi-file editing agent mode, and inline chat. Because Cursor is built on VS Code, it inherits full Remote SSH and DevContainer support out of the box. Cursor lists Hobby (free), Individual $20 per user per month, Teams $40 per user per month, and custom Enterprise pricing on cursor.com/pricing (as of July 2026).

  • Codebase-aware completions - AI understands your entire project context, not just the open file
  • Agent mode - Autonomous multi-file editing that can refactor across your codebase
  • Enterprise sandboxing controls - Policy over agent auto-run, browser access, and network access, plus service accounts for non-interactive runs
  • VS Code compatible - All Remote SSH and DevContainer extensions work natively

CDE Integration

// Cursor settings.json for CDE
{
  // Remote SSH (same as VS Code)
  "remote.SSH.remotePlatform": {
    "cde-workspace": "linux"
  },
  "remote.SSH.connectTimeout": 60,

  // Cursor AI settings
  "cursor.ai.enabled": true,
  "cursor.ai.codebaseIndexing": true,

  // Agent mode for multi-file edits
  "cursor.composer.enabled": true,

  // Privacy: keep code on your CDE
  "cursor.general.enableTelemetry": false
}

Tip: Cursor's codebase indexing works best when the project is on the remote CDE. Use Remote SSH to connect, then let the indexer run on the remote filesystem for fastest results.

Windsurf / Devin Desktop

Cognition's editor line, with Cascade autonomous editing

Who owns Windsurf, and why it matters

The product shipped first as Codeium, then renamed to Windsurf. In July 2025 Google DeepMind took a non-exclusive license to the technology and hired the CEO, a co-founder, and key research staff - a license plus acqui-hire, not an acquisition of the company or the editor. On 07-14-2025 Cognition acquired the remaining Windsurf entity outright, including the IDE, the brand, the IP, the customers, and the staff. Cognition shipped Devin in Windsurf on 04-15-2026, then Devin Desktop on 06-02-2026, which it describes as the next generation of Windsurf.

  • Cascade AI - Autonomous multi-file editing with deep project understanding
  • Backwards compatible - Devin Desktop retains compatibility with existing Windsurf setups, and adds an Agent Command Center
  • ACP support - Devin Desktop speaks the Agent Client Protocol, so the agent is not locked to the editor
  • Devin plan pricing - Free, Pro $20/month, Max $200/month, Teams $80/month plus $40/month per developer seat, Enterprise custom (devin.ai/pricing, July 2026). The former $500/month minimum and ACU billing are retired.

CDE Workflow Tips

// Windsurf settings for CDE
{
  // Remote connection (VS Code compatible)
  "remote.SSH.remotePlatform": {
    "cde-workspace": "linux"
  },

  // Cascade AI settings
  "windsurf.cascade.enabled": true,
  "windsurf.cascade.autoContext": true,

  // Index remote workspace
  "windsurf.indexing.enabled": true,
  "windsurf.indexing.excludePaths": [
    "node_modules", ".git", "dist"
  ]
}

Tip: Cascade works best with a well-structured codebase. CDE templates with consistent project layouts let Cascade build richer context from the start.

Dotfiles & Personalization

Sync your personal configuration across all workspaces

Dotfiles Repository Structure

dotfiles/
+-- install.sh          # Bootstrap script
+-- .bashrc             # Bash config
+-- .zshrc              # Zsh config
+-- .gitconfig          # Git settings
+-- .tmux.conf          # Tmux config
+-- .vimrc              # Vim config
+-- nvim/
|   \-- init.lua        # Neovim config
+-- vscode/
|   \-- settings.json   # VS Code settings
\-- scripts/
    \-- cde-setup.sh    # CDE-specific setup

Bootstrap Script (install.sh)

#!/bin/bash
# Clone and setup dotfiles

DOTFILES="$HOME/.dotfiles"

# Clone if not exists
if [ ! -d "$DOTFILES" ]; then
  git clone https://github.com/you/dotfiles "$DOTFILES"
fi

# Symlink configs
ln -sf "$DOTFILES/.bashrc" "$HOME/.bashrc"
ln -sf "$DOTFILES/.gitconfig" "$HOME/.gitconfig"
ln -sf "$DOTFILES/.tmux.conf" "$HOME/.tmux.conf"
ln -sf "$DOTFILES/nvim" "$HOME/.config/nvim"

echo "Dotfiles installed!"

Coder

# coder.yaml template
dotfiles_uri: https://github.com/you/dotfiles
dotfiles_install_command: ./install.sh

Codespaces

// devcontainer.json
"dotfiles.repository": "you/dotfiles",
"dotfiles.targetPath": "~/.dotfiles",
"dotfiles.installCommand": "./install.sh"

Ona (formerly Gitpod)

# .gitpod.yml
tasks:
  - before: |
      git clone https://github.com/you/dotfiles ~/.dotfiles
      ~/.dotfiles/install.sh