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 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 GPU Computing
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
Operations
Performance Optimization High Availability & DR Disaster Recovery Monitoring Capacity Planning Multi-Cluster Development Troubleshooting Runbooks Ephemeral Environments
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 Governance
Planning
Pilot Program Design Stakeholder Communication Risk Management Migration Guide Cost Analysis FinOps GreenOps Vendor Evaluation Training Resources Developer Onboarding Team Structure DevEx Metrics Industry Guides
Resources
Tools Comparison CDE vs Alternatives Case Studies Lessons Learned Glossary FAQ

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.

The AI-Native IDE Era: In 2026, IDEs are being redefined by native AI integration. Beyond traditional code editors, a new generation of AI-native IDEs - Cursor, Windsurf, and Zed - are reshaping developer workflows with intelligent completions, autonomous multi-file editing, and deep contextual understanding built directly into the editor experience.

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

JetBrains 2026.1 - Architecture Redesign

The 2026.1 release includes a significant architecture redesign for improved remote performance. The new thin-client protocol reduces bandwidth usage by up to 40%, delivers faster indexing on remote hosts, and provides a more responsive editing experience over high-latency connections. If you are running Gateway with CDE workspaces, upgrading to 2026.1 is strongly recommended for the best remote development experience.

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 running at 120fps with native DevContainer support (v0.218+), built-in AI integration, and multiplayer editing. Free and open-source, Zed is purpose-built for the performance demands of remote and cloud development.

  • 120fps rendering - GPU-accelerated UI stays fluid even over remote connections
  • Native DevContainers - Built-in support since v0.218+, no extensions needed
  • Built-in AI assistant - Integrated AI chat and inline completions
  • 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 ($20/mo Pro). 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.

  • 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
  • Inline chat - Ask questions and get edits without leaving your code flow
  • 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

AI-powered IDE with Cascade autonomous editing

Why Windsurf for CDEs

Windsurf by Codeium ($15/mo) features Cascade AI for autonomous multi-file editing and deep contextual understanding. Its AI engine maintains awareness of your entire codebase, making it especially powerful for large projects running on CDE infrastructure.

  • Cascade AI - Autonomous multi-file editing with deep project understanding
  • Contextual awareness - AI tracks your recent changes and intent across sessions
  • Affordable pricing - $15/mo makes AI-assisted development accessible for teams
  • VS Code extensions - Compatible with the VS Code extension ecosystem for remote workflows

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