La programación asistida por IA vive un momento de madurez. Hoy distinguimos con claridad dos familias de herramientas que usamos a diario: las que trabajan en la terminal, con interfaces tipo CLI/TUI, y las que se integran como IDEs completos con chat y edición guiada. Al evaluar qué conviene adoptar en cada proyecto, confirmamos tres hechos verificables. Primero, las funciones tienden a converger, aunque la experiencia de uso difiere mucho. Segundo, la compatibilidad con modelos y estándares se mueve rápido y conviene revisarla antes de decidir. Tercero, la calidad final depende menos del logo elegido y más de cómo configuramos reglas, memoria y agentes en cada entorno.

La decisión técnica útil no es “qué herramienta gana”, sino “con cuál trabajamos mejor en esta tarea concreta, con estos modelos y estas reglas”.

En esta guía repasamos lo que hoy ofrecen los cuatro nombres que más vemos en equipos de producto: Claude Code en la terminal, OpenCode como agente open source con CLI y app de escritorio, Cursor como fork de VS Code con IA profunda, y VS Code con GitHub Copilot integrado. Contrastamos datos clave con documentación reciente y recogemos prácticas de trabajo que nos ahorran tiempo cuando el agente pasa de “ayudante” a “coautor” de cambios en un repositorio.

En el terreno funcional encontramos puntos firmes. En terminal ganamos control y menos distracción, a cambio de perder el auto‑completion inline del editor. En IDE obtenemos inline suggestions, vista de diffs y edición asistida a nivel de archivo y proyecto. Donde todos coinciden es en el “modo agente”: planificar, aplicar cambios, ejecutar comandos y devolver una propuesta con justificación. Aquí la calidad no solo depende del modelo, también de cómo alimentamos contexto persistente, reglas del proyecto y acceso a herramientas externas mediante protocolos abiertos como MCP.

A continuación, ordenamos el panorama y compartimos procedimientos que nos han funcionado con equipos de distintos tamaños.

Qué hay realmente detrás de cada herramienta

Cuando trabajamos con IDEs con IA, solemos centrarnos en dos nombres: Cursor, desarrollado por la empresa estadounidense Anysphere, y VS Code con GitHub Copilot. Cursor es un fork de VS Code con IA integrada en la edición y el chat, y nos permite definir reglas persistentes para el agente en archivos del proyecto. GitHub Copilot, por su parte, se integra en VS Code e incorpora desde 2025 un “agent mode” capaz de buscar contexto, proponer cambios y ejecutar comandos, siempre con confirmación.

El frame presenta un diagrama conceptual sobre un fondo oscuro. En la parte supe
Interfaces: CLIs, TUIs e IDEs

Detrás de Cursor está Anysphere, fundada por un equipo del MIT que lidera Michael Truell. En 2025 y 2026 vimos cómo la compañía consolidó su foco en “vibe coding”, una experiencia en la que el agente navega el repositorio, edita y valida cambios con mínima fricción.

En terminal, solemos apoyarnos en Claude Code de Anthropic como agente de codificación con lectura, edición y ejecución en el directorio de trabajo. La novedad de enero de 2026 es clave: Ollama ofrece compatibilidad con la API de mensajes de Anthropic, de modo que podemos lanzar Claude Code contra modelos abiertos locales o de su nube, sin cambiar flujos. Esta puerta amplía la elección de modelos cuando el hardware lo permite o cuando queremos aislar el código en local.

También trabajamos con OpenCode, un proyecto open source que funciona como agente de codificación en CLI, con app de escritorio y extensiones. Integra decenas de proveedores a través de Models.dev y, si ya contamos con suscripciones, iniciamos sesión con GitHub Copilot o con cuentas de OpenAI. Es flexible para equipos que combinan local, nubes y proveedores múltiples.

La frontera útil ya no es “IA sí o no”, sino “qué capa de agencia necesitamos y cómo la gobernamos con reglas, contexto y herramientas”.

Un vistazo a la actividad en repositorios

En los agentes open source, nos importan la frecuencia de cambios y la organización interna para evaluar su madurez. Este tipo de estructura es habitual en repositorios activos de agentes y extensiones:

CLIs/TUIs frente a IDEs: diferencias prácticas en el día a día

Nos movemos entre dos estilos. En CLI/TUI trabajamos dentro del proyecto, con foco en el prompt y los comandos del sistema. En IDE, el agente convive con el editor, las inline suggestions, la búsqueda y las vistas de cambios. ¿Qué diferencias notamos en tareas reales?

  • En refactors amplios, un IDE nos aporta una vista de diffs por archivo y la posibilidad de aceptar o revertir cambios por bloque. Ahí Cursor y Copilot destacan con edición guiada y controles de seguridad que piden confirmación antes de ejecutar comandos.
  • En generación de módulos “de cero”, CLI/TUI nos da velocidad cuando el agente puede crear carpetas, archivos y ejecutar tests sin abandonar la terminal. En Claude Code, la sesión mantiene el contexto del directorio y registra los comandos ejecutados.
  • En debugging asistido, el modo agente en IDE facilita leer trazas, aplicar parches y lanzar el build o los tests desde el panel de chat. Cursor, por ejemplo, permite combinar reglas de proyecto con edición en bloque para aplicar el plan del agente.
El frame presenta un esquema comparativo que organiza dos categorías de herramie
Comparativa de herramientas de programación e IA

Imaginemos un caso concreto. Tenemos una API en FastAPI y queremos añadir el endpoint GET /health con verificación de base de datos.

  • En IDE, abrimos el archivo app/api/health.py, pedimos al chat “crear endpoint /health que devuelva {status:'ok'} y pruebe conexión con SQLAlchemy”. El agente propone cambios en uno o varios archivos, muestra el diff y nos deja ejecutar el test generado.
  • En CLI/TUI con Claude Code, arrancamos en la raíz del repo y pedimos el mismo cambio. El agente crea archivos, ejecuta pytest y devuelve el resultado en el flujo de la terminal. Si necesitamos contexto estable, añadimos instrucciones a CLAUDE.md sobre cómo inicializar la sesión y qué fixtures usar.

Elijas lo que elijas, lo decisivo es el “andamiaje” de contexto: reglas, memoria y acceso a herramientas externas.

Modelos y compatibilidad: de Claude a los abiertos con Ollama

En 2026 ya no nos preguntamos si un agente soporta “tal o cual modelo”, sino cómo lo configuramos para aprovechar el que necesitamos en cada proyecto.

  • Claude Code está pensado para modelos de Anthropic, pero desde el 16 de enero de 2026 Ollama ofrece compatibilidad con la API de mensajes de Anthropic. Eso permite usar Claude Code con modelos abiertos locales o con los modelos en la nube de Ollama, ajustando la longitud de contexto y los límites de sesión. El procedimiento se reduce a exportar tres variables (ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY) y ejecutar claude --model ....
  • OpenCode integra múltiples proveedores a través de Models.dev y puede trabajar con credenciales existentes. Si ya pagamos Copilot en GitHub, iniciamos sesión y usamos esa capacidad desde el agente de OpenCode en terminal o en su app de escritorio. Para orquestar servidores MCP, el propio CLI trae comando opencode mcp para alta y gestión.
  • VS Code + GitHub Copilot incorporó en 2025 un “agent mode” con mejoras continuas: búsqueda de contexto en el workspace, sugerencias de próxima edición y ejecución de tareas del build bajo confirmación explícita. Esto acerca Copilot a un flujo agentic donde el IDE coordina la secuencia de pasos.
  • Cursor permite seleccionar reglas y persistir instrucciones mediante AGENTS.md o directorios .cursor/rules, además de sus formatos heredados. La selección del modelo y el comportamiento del agente la controlamos desde el editor y la combinamos con reglas de proyecto.

Aquí conviene añadir un matiz. La estandarización está avanzando. El Model Context Protocol (MCP), nacido en 2024, se ha consolidado como protocolo para que los agentes se conecten a aplicaciones y datos. En 2025, Anthropic donó MCP a la Linux Foundation en el marco de la nueva Agentic AI Foundation (AAIF), y OpenAI transfirió AGENTS.md al mismo consorcio. Esto acelera la interoperabilidad entre herramientas y reduce el costo de cambiar de cliente.

En la práctica, ya instalamos servidores MCP para dar “brazos” al agente. Uno popular es el Playwright MCP Server, que ofrece navegación y acciones de navegador para pruebas, scraping o verificación de documentación. Hay implementaciones mantenidas por la comunidad y también un repositorio oficial de Microsoft.

Los protocolos abiertos como MCP y los archivos de reglas compartidos están homogeneizando el ecosistema. Elegimos clientes por UX y por integración con nuestro workflow, no por un “jardín amurallado”.

Memoria, reglas y estandarización: CLAUDE.md, AGENTS.md y reglas de editor

La calidad del agente sube cuando persistimos conocimiento del proyecto en archivos que el sistema considera “de alto nivel”. Este es el trío que hoy usamos con más frecuencia:

  • CLAUDE.md y la carpeta .claude/rules/ en proyectos donde trabajamos con Claude Code. Colocamos ahí estándares de estilo, arquitectura, cómo correr tests y convenciones de branching. Claude Code lee ese contenido con prioridad de sistema para ajustar su comportamiento a nuestro repositorio.
  • AGENTS.md, que se ha convertido en un formato de facto para dar instrucciones al agente en proyectos multiplataforma. Cursor lo soporta como alternativa simple cuando no queremos granularidad por archivos.
  • .cursor/rules/, con reglas en formato MDC en el caso de Cursor. Cada regla puede ser “Always”, “Auto Attached”, “Agent Requested” o “Manual”, lo que nos permite encender instrucciones según patrones de ruta, invocación del agente o decisión del propio modelo.

Dos recomendaciones operativas que nos ahorran tiempo:

  • Si el proyecto es grande, es mejor modularizar reglas por directorio y tema que concentrarlas en un único archivo. Así reducimos ruido en el contexto y orientamos al agente a lo que importa en cada zona del repo.
  • Es sano revisar periódicamente qué reglas “siempre activas” están influyendo en chat y edición. En flujos agentic, una regla mal calibrada puede causar ediciones reiterativas o planes que ignoran convenciones locales.

Ejemplo directo

Supón que tu servicio exige que todas las rutas API validen entrada con Zod y expongan errores { error: string, code: number }. En Cursor, añadimos un archivo .cursor/rules/api.mdc marcado como “Auto Attached” para src/api/**/*.ts. En Claude Code, creamos .claude/rules/api.md con las mismas pautas y un fragmento de bash para correr tests. A partir de ahí, cuando el agente planifique cambios en esos archivos, las reglas guían el plan sin que tengamos que recordarlo en cada prompt.

Instalación

En entornos mixtos nos resulta útil tener a mano una configuración base reproducible. Estos pasos sirven como referencia para Claude Code con modelos abiertos vía Ollama, y para OpenCode como agente open source.

Instalar y preparar Claude Code

Claude Code es el agente en terminal de Anthropic. Lo descargamos con el script oficial y verificamos que se añadió al PATH.

# macOS, Linux o WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

Conectar Claude Code a Ollama

Desde el 16 de enero de 2026, Ollama es compatible con la API de mensajes de Anthropic. Configuramos las variables y ejecutamos Claude Code contra un modelo abierto, local o en la nube de Ollama. Recomendamos contextos amplios para tareas de código.

# variables mínimas para compatibilidad Anthropic
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434
export ANTHROPIC_API_KEY=""

# ejemplo: lanzar con un modelo de código
claude --model qwen3-coder

Instalar OpenCode

OpenCode es un agente open source que podemos usar en la terminal o en su app de escritorio. Se instala con un único comando y permite iniciar sesión con GitHub para aprovechar la cuenta de Copilot si ya la tenemos.

# instalación rápida del CLI
curl -fsSL https://opencode.ai/install | bash

Añadir servidores MCP cuando el agente necesite “brazos”

Para navegación o pruebas de interfaz, instalamos un Playwright MCP Server y lo declaramos en la configuración del cliente compatible. La variante de Microsoft ofrece una ruta estable y bien documentada.

{
 "mcpServers": {
 "playwright": {
 "command": "npx",
 "args": [
 "@playwright/mcp@latest"
 ]
 }
 }
}

Entre pasos, recordemos crear CLAUDE.md, AGENTS.md o reglas en .cursor/rules para inyectar conocimiento del proyecto. Esto suele marcar más diferencia que cambiar de modelo.

Consejos

Si priorizamos editar a gran escala con vista de cambios e integración con builds, un IDE con agente y reglas por proyecto nos hará trabajar más rápido. Cursor encaja bien cuando queremos granularidad en reglas y edición contextual. VS Code con Copilot ha ganado terreno con su agent mode y controles de ejecución.

  • Si necesitamos aislamiento, auditoría y control fino de lo que se ejecuta, CLI/TUI con Claude Code y Ollama nos da un canal claro, reproducible y sin dependencia de un editor específico.
  • Si el equipo mezcla proveedores y quiere experimentar con diferentes modelos sin rehacer flujos, OpenCode ofrece esa flexibilidad con gestión de agentes, MCP y credenciales unificadas.
En proyectos reales, la “mejor” opción cambia por tarea, por modelo y por cómo fijamos memoria y reglas. El triunfo es que hoy podemos mezclar sin fricción.

Conclusiones

El ecosistema de agentes para programar se está normalizando. Lo vemos en tres frentes. Primero, estándares: MCP y AGENTS.md empujan a que las herramientas “hablen el mismo idioma” y compartan prácticas para reglas y memoria. Segundo, interoperabilidad de modelos: Claude Code trabajando con modelos abiertos vía Ollama cambia el tablero y permite optimizar por coste, latencia o privacidad sin rehacer flujos. Tercero, experiencia unificada: los IDEs con agente y los CLIs maduros ofrecen caminos equivalentes para planificar, editar, validar y ejecutar.

Nos quedamos con una pauta práctica. Si vamos a adoptar uno de estos entornos, definamos antes el andamiaje: reglas del proyecto, memoria persistente y servidores MCP que necesita nuestro dominio. Después, elijamos la interfaz que mejor encaje con nuestro workflow. En 2026, cualquiera de las cuatro opciones que hemos revisado nos permite entregar código de calidad si ponemos el contexto correcto en el lugar adecuado.

Y una última idea. No hay atajos mágicos. Lo que más influye en la calidad final sigue siendo nuestra manera de conversar con el agente, cómo escribimos CLAUDE.md o AGENTS.md, y la disciplina para revisar los planes de cambio que propone. Elegimos la herramienta por su encaje operativo, la configuramos con reglas claras y dejamos que la IA haga lo que mejor sabe hacer: acelerar nuestro trabajo sin romper la arquitectura ni el estilo de equipo.

Comparte esta publicación