VS Code a punto para IA

Un editor bien configurado te avisa de los errores antes de que ejecutes nada.

Qué vas a aprender

• Instalar VS Code con las extensiones esenciales para Python, Jupyter, linting y SSH remoto
• Configurar el formateo al guardar, la comprobación de tipos y el scroll de salidas de notebooks
• Configurar Remote SSH para editar y depurar código en máquinas remotas con GPU como si fueran locales
• Valorar alternativas (Cursor, Windsurf, Neovim) y sus pros y contras para trabajar en IA

Por qué importa

Vas a pasar miles de horas dentro de tu editor escribiendo Python, ejecutando notebooks, depurando bucles de entrenamiento y conectándote por SSH a máquinas con GPU. Un editor mal configurado convierte cada sesión en fricción: sin autocompletado, sin pistas de tipos, sin errores en línea, formateando a mano y peleándote con la terminal.

La configuración correcta lleva 20 minutos. Saltártela te cuesta 20 minutos cada día.

La idea clave

Un editor para ingeniería de IA necesita cinco cosas:

graph TD
    L5["5. Desarrollo remoto<br/>SSH a máquinas con GPU y VMs en la nube"] --> L4
    L4["4. Terminal integrada<br/>Ejecutar scripts, depurar, vigilar la GPU"] --> L3
    L3["3. Ajustes para IA<br/>Formateo automático, tipos, reglas de margen"] --> L2
    L2["2. Extensiones<br/>Python, Jupyter, Pylance, GitLens"] --> L1
    L1["1. Editor base<br/>VS Code: gratis, extensible, universal"]

Por debajo, casi todo lo «inteligente» del editor (autocompletado, ir a la definición, errores en rojo) funciona gracias al LSP (Language Server Protocol): el editor habla con un servidor específico del lenguaje que analiza tu código y le devuelve la información.

Paso a paso

Paso 1: instala VS Code

VS Code es el editor recomendado: es gratis, funciona en cualquier sistema, tiene soporte de primera para notebooks de Jupyter y su ecosistema de extensiones cubre todo lo que necesitas para IA.

Descárgalo en code.visualstudio.com.

Compruébalo desde la terminal:

code --version

Si en macOS no encuentra el comando code, abre VS Code, pulsa Cmd+Shift+P, escribe «Shell Command» y elige «Install 'code' command in PATH».

Paso 2: instala las extensiones esenciales

Abre la terminal integrada de VS Code (Ctrl+` en cualquier plataforma) e instala las extensiones que importan para IA:

code --install-extension ms-python.python
code --install-extension ms-python.vscode-pylance
code --install-extension ms-toolsai.jupyter
code --install-extension eamodio.gitlens
code --install-extension ms-vscode-remote.remote-ssh
code --install-extension ms-python.debugpy
code --install-extension ms-python.black-formatter
code --install-extension charliermarsh.ruff

Para qué sirve cada una:

En «Archivos de la lección» tienes vscode/extensions.json con la lista completa de recomendaciones. Crea una carpeta .vscode (con punto) dentro de tu proyecto y guarda ahí el archivo: al abrir la carpeta del proyecto, VS Code te propondrá instalarlas.

Paso 3: configura los ajustes

Descarga vscode/settings.json de «Archivos de la lección» y guárdalo también en la carpeta .vscode de tu proyecto, o copia los ajustes a mano en Settings › Open Settings (JSON).

Los ajustes clave para IA:

{
    "python.analysis.typeCheckingMode": "basic",
    "editor.formatOnSave": true,
    "editor.rulers": [88, 120],
    "notebook.output.scrolling": true,
    "files.autoSave": "afterDelay"
}

Por qué importan:

• Comprobación de tipos en basic: detecta tipos de argumento incorrectos antes de ejecutar. Te ahorra depurar parámetros erróneos en llamadas a APIs o dimensiones de tensores mal pasadas.
• Formatear al guardar: no vuelves a pensar en el formato. Black se encarga.
• Reglas en 88 y 120: Black corta las líneas en 88 caracteres. La marca de 120 te avisa cuando docstrings y comentarios se alargan demasiado.
• Scroll en la salida de notebooks: los bucles de entrenamiento imprimen miles de líneas. Sin scroll, el panel de salida se desborda.
• Autoguardado: se te olvidará guardar, y tu script de entrenamiento ejecutará código antiguo. El autoguardado lo evita.

Paso 4: integración con la terminal

La terminal integrada de VS Code es donde lanzarás los entrenamientos, vigilarás las GPUs y gestionarás los entornos.

Configúrala bien:

{
    "terminal.integrated.defaultProfile.osx": "zsh",
    "terminal.integrated.defaultProfile.linux": "bash",
    "terminal.integrated.fontSize": 13,
    "terminal.integrated.scrollback": 10000
}

Atajos útiles:

Dividir la terminal es muy práctico: en una ejecutas tu script y en la otra vigilas la GPU con nvidia-smi -l 1 o watch -n 1 nvidia-smi.

Paso 5: desarrollo remoto (SSH a máquinas con GPU)

Es la extensión más importante para trabajar en IA. Entrenarás en máquinas remotas (VMs en la nube, servidores del laboratorio, Lambda, Vast.ai…). Remote SSH te permite abrir su sistema de archivos, editar, usar terminales y depurar como si todo fuera local.

Configuración:

1. Instala la extensión Remote SSH (ya lo hiciste en el paso 2).
2. Pulsa Ctrl+Shift+P (o Cmd+Shift+P) y escribe «Remote-SSH: Connect to Host».
3. Introduce usuario@ip-de-tu-maquina-gpu.
4. VS Code instala automáticamente su componente de servidor en la máquina remota.

Para entrar sin contraseña, configura claves SSH:

ssh-keygen -t ed25519 -C "tu-email@ejemplo.com"
ssh-copy-id usuario@ip-de-tu-maquina-gpu

Y añade el host a ~/.ssh/config para mayor comodidad:

Host gpu-box
    HostName 203.0.113.50
    User ubuntu
    IdentityFile ~/.ssh/id_ed25519
    ForwardAgent yes

Ahora Remote-SSH: Connect to Host › gpu-box conecta al instante.

Alternativas

Cursor

cursor.com es un fork de VS Code con generación de código por IA integrada. Usa el mismo ecosistema de extensiones y el mismo formato de ajustes, así que todo lo de esta lección sigue valiendo: importa los mismos settings.json y extensions.json.

Windsurf

windsurf.com es otro fork de VS Code centrado en la IA. Misma historia: mismas extensiones, mismo formato de ajustes y mismo soporte de Remote SSH.

Vim/Neovim

Si ya usas Vim o Neovim y eres productivo con él, quédate ahí. Lo mínimo para trabajar con Python en IA:

• pyright o pylsp para la comprobación de tipos (con Mason o instalación manual)
• nvim-lspconfig para integrar el servidor de lenguaje
• jupyter-vim o molten-nvim para ejecutar código al estilo notebook
• telescope.nvim para buscar archivos y símbolos
• none-ls.nvim con black y ruff para formateo y linting

Si no usas Vim, no empieces ahora: su curva de aprendizaje competiría con la de la ingeniería de IA. Usa VS Code.

¿Y los asistentes de código con IA? Copilot, Claude Code, Cursor y compañía aceleran muchísimo el trabajo, y aprenderás a construirlos en el módulo 20 (Agentes de código). Mientras aprendes, úsalos como tutor, no como piloto automático: intenta primero resolver tú los ejercicios y pídeles que te expliquen el código que no entiendas. Si no puedes explicar una línea, todavía no es tuya.

En la práctica

Con esta configuración, tu flujo diario será:

1. Abrir la carpeta del proyecto en VS Code (o conectarte por Remote SSH a una máquina con GPU).
2. Escribir Python con autocompletado, pistas de tipos y errores en línea.
3. Ejecutar notebooks de Jupyter dentro del editor.
4. Usar la terminal integrada para los entrenamientos, uv pip install y vigilar la GPU.
5. Revisar los cambios con GitLens antes de hacer commit.

Retos para tu ordenador

1. Instala VS Code y todas las extensiones del paso 2
2. Copia el settings.json de esta lección en tu configuración de VS Code
3. Abre un archivo de Python y comprueba que Pylance muestra pistas de tipos y que Black formatea al guardar
4. Si tienes acceso a una máquina remota, configura Remote SSH y abre una carpeta en ella

Glosario de la lección