Saltar al contenido principal

Agentes de codificación locales (y cómo se combinan con Claude)

Intermedio

Un agente de codificación local es un programa que se ejecuta en tu propia máquina, lee tu repositorio y edita tus archivos por ti. Describes un cambio en lenguaje natural; el agente lo planifica, escribe código a lo largo de varios archivos, ejecuta tus pruebas, lee los fallos y vuelve a intentarlo — un bucle, no una única respuesta. El asistente de chat en una pestaña del navegador te entrega un fragmento para que lo pegues; un agente de codificación hace por sí mismo el pegar, el ejecutar y el corregir, dentro de tu repositorio.

La idea clave que hace que valga la pena leer esta página: casi todas estas herramientas son agnósticas respecto al modelo. El agente (el bucle que toca tus archivos) está separado del modelo (el cerebro que decide qué escribir). Así que la misma herramienta se puede apuntar a Claude para la mejor calidad de código, o a un modelo local de pesos abiertos vía Ollama para que tu código nunca salga de tu portátil. Eliges el agente por cómo encaja en tu flujo de trabajo, y el modelo por el compromiso entre calidad y privacidad — de forma independiente.

What you'll learn
  • Entender el arquetipo del agente de codificación: un bucle de agente que lee tu repositorio, planifica, edita archivos, ejecuta pruebas e itera
  • Conocer las herramientas abiertas reales — Aider, Cline, Continue, OpenHands — y cómo encaja el propio Claude Code de Anthropic
  • Comprender por qué importa que sea 'agnóstico respecto al modelo': apuntar un mismo agente a Claude para calidad O a un modelo local para privacidad
  • Entender el ángulo de la privacidad — un modelo local significa que tu código nunca sale de tu máquina
  • Elegir a lo largo de dos ejes: integrado en el IDE vs CLI vs autónomo, e impulsado por Claude vs totalmente local

El arquetipo: un bucle de agente, no una caja de chat​

Cada herramienta de esta página es una variación del mismo bucle. Una vez que ves el bucle, cada herramienta no es más que una forma distinta a su alrededor:

  1. Leer — el agente reúne contexto: los archivos que le indicas, la estructura del repositorio, a veces la salida de las pruebas o los registros de errores.
  2. Planificar — decide qué cambiar y en qué archivos, a menudo proponiendo un plan antes de tocar nada.
  3. Editar — escribe cambios en archivos reales en disco (normalmente mostrados como un diff que apruebas).
  4. Ejecutar — ejecuta comandos: tu suite de pruebas, una compilación, un linter, un script.
  5. Observar e iterar — lee lo que ocurrió (¿pasaron las pruebas? ¿un stack trace?) y vuelve al paso 2 hasta que la tarea esté terminada o te devuelva el control.

Esta es la misma forma que el uso de herramientas agéntico: al modelo se le dan herramientas (leer archivo, editar archivo, ejecutar comando) y decide cuándo llamarlas. La diferencia entre herramientas está principalmente en cuánta autonomía tiene el bucle y dónde vive — tu terminal, tu editor o un entorno aislado que se ejecuta por su cuenta.

El modelo en medio de ese bucle es intercambiable. Esa es la razón entera por la que un único agente puede servir a dos usuarios muy distintos: alguien que quiere el código más potente posible (apúntalo a Claude) y alguien que legalmente no puede dejar que el código salga de su red (apúntalo a un modelo local).

Por qué ser agnóstico respecto al modelo es la característica estrella​

El agente y el modelo son piezas separadas. El agente es dueño del bucle — leer archivos, aplicar diffs, ejecutar pruebas. El modelo es dueño del juicio — qué escribir, por qué y cuándo parar. Desacoplarlos te da dos diales independientes:

  • Dial de calidad → Claude. Para razonamiento difícil, refactorizaciones multi-archivo y trabajo de contexto largo, un modelo de frontera como Claude produce ediciones notablemente mejores y se recupera de los fallos de forma más fiable. La mayoría de estas herramientas documentan a Claude como una opción recomendada o predeterminada. (Qué nivel de Claude elegir es una decisión propia — véase Elegir un modelo.)
  • Dial de privacidad → un modelo local. Apunta el mismo agente a un modelo de pesos abiertos ejecutándose bajo Ollama y tu código, tus prompts y tus diffs nunca salen de tu máquina — ninguna llamada a la API, ningún tercero, nada por el cable. Ese es el factor decisivo para bases de código reguladas, aisladas (air-gapped) o confidenciales. El compromiso honesto: un modelo lo bastante pequeño como para ejecutarse en un portátil no está a la altura de un modelo de frontera en las tareas más difíciles. Estás cambiando algo de capacidad por control total de los datos.
What you'll learn
  • Agnóstico respecto al modelo no significa que todos los modelos sean igual de buenos. El bucle se ejecuta igual, pero un modelo débil hace peores ediciones, malinterpreta los fallos de las pruebas e itera de forma improductiva. La privacidad y la capacidad realmente se compensan entre sí — elige por tarea, no una vez para siempre.

Las herramientas reales (verificadas)​

Cinco herramientas que vale la pena conocer. Las primeras cuatro son de código abierto y agnósticas respecto al modelo; la quinta es el propio agente de Anthropic, incluido para que puedas ver dónde encaja una experiencia nativa de Claude.

Aider — el programador de parejas en CLI​

Aider se ejecuta en tu terminal y está construido en torno a git: edita archivos en tu repositorio y confirma automáticamente cada cambio con un mensaje sensato, de modo que cada edición de IA es un diff que puedes revisar, deshacer o revertir. Es agnóstico respecto al modelo — funciona mejor con modelos de frontera como Claude, y también se conecta a modelos locales vía Ollama (aider --model ollama_chat/<model>). Si vives en la terminal y quieres una higiene de git estricta, Aider es la opción canónica de CLI.

Cline — el agente dentro de tu IDE​

Cline es un agente de codificación de código abierto que vive en tu editor (VS Code y JetBrains) y también ofrece una superficie de terminal/CLI. Crea archivos, ejecuta comandos y usa herramientas con aprobación humana en el bucle — ves y apruebas cada paso. Es agnóstico respecto al modelo y admite explícitamente Claude además de modelos locales vía Ollama o LM Studio. Recurre a Cline cuando quieras un agente casi autónomo sin salir de tu editor.

Roo Code es un fork bien conocido de Cline que añadió "modos" personalizados (p. ej. un modo Architect para planificar, un modo Coder para editar). También era agnóstico respecto al modelo. Ten en cuenta su estado más abajo — ya no es la opción predeterminada segura que fue antes.

Continue — el asistente de IDE abierto​

Continue es un asistente de código abierto para VS Code y JetBrains (además de una CLI) que cubre chat, edición, autocompletado y un modo agente. Es completamente agnóstico respecto al modelo: su documentación enumera Anthropic (Claude), Ollama para modelos locales y muchos otros proveedores, con distintos modelos asignables a distintos roles (chat, edición, autocompletado). Es una opción sólida si quieres un asistente configurable en el que conectes exactamente qué modelo hace qué.

OpenHands — el agente autónomo​

OpenHands (antes OpenDevin) es el más autónomo de los cuatro: una plataforma para agentes de desarrollo de software de IA que trabajan en un entorno aislado (sandbox), descomponen una tarea (p. ej. un issue de GitHub) y la llevan a cabo de principio a fin con menos aprobaciones paso a paso. Es agnóstico respecto al modelo — "úsalo con cualquier LLM", Claude incluido — y puede ejecutarse de forma autoalojada. Elige OpenHands cuando quieras delegar una tarea entera y volver a comprobarla, en lugar de aprobar cada edición.

Claude Code — el propio agente de Anthropic​

Claude Code es la herramienta de codificación agéntica oficial de Anthropic: lee tu base de código, edita archivos, ejecuta comandos y pruebas, y funciona en tu terminal, IDE, aplicación de escritorio y la web. A diferencia de las cuatro anteriores, no es "apúntalo a cualquier modelo" — está construido en torno a Claude y ajustado para él, que es exactamente por lo que el bucle se siente más ajustado y las ediciones aciertan más a menudo en tareas difíciles. Si tu prioridad es la mejor experiencia de codificación impulsada por Claude en lugar de la máxima intercambiabilidad de modelos, este es el camino nativo. Todo el detalle en Qué es Claude Code.

Cómo elegir​

Dos ejes deciden casi todo:

Eje 1 — dónde vive el agente:

  • CLI / terminal (Aider, Claude Code) — programable, amigable con git, encauzable hacia otras herramientas. Mejor si vives en el shell.
  • Integrado en el IDE (Cline, Continue, la superficie de editor de Claude Code) — diffs y aprobaciones dentro de tu editor, con tu código ahí mismo. Mejor para la edición diaria.
  • Autónomo / aislado (OpenHands) — delega una tarea entera y revisa el resultado. Mejor para trabajo por lotes o desatendido.

Eje 2 — impulsado por Claude vs totalmente local:

  • Impulsado por Claude — la mejor calidad, especialmente en tareas difíciles multi-archivo o de contexto largo. Tu código se envía a la API del modelo. Elígelo cuando la calidad importe más y tu código pueda enviarse a un proveedor.
  • Totalmente local (Ollama) — tu código nunca sale de la máquina; gratis de ejecutar; funciona sin conexión. Elígelo cuando la privacidad, la regulación o el aislamiento (air-gapping) sean innegociables — aceptando que un modelo del tamaño de un portátil es más débil en las tareas más difíciles.

El movimiento duradero: elige el agente por la superficie que encaja en tu flujo de trabajo, luego elige el modelo por tarea. Nada te impide ejecutar un agente de IDE sobre un modelo local para el repositorio confidencial y el mismo agente sobre Claude para todo lo demás.

Elige y configura un agente de codificación​

Guided walkthrough1 of 5
  1. CLI (Aider, Claude Code), integrado en el IDE (Cline, Continue) o autónomo (OpenHands). Ajústalo a donde ya trabajas — terminal vs editor vs delegar-y-revisar.

Una primera ejecución concreta con Aider apuntado a un modelo local (privado, gratis, sin conexión) — descarga primero el modelo con Ollama, luego:

Ejecutar Aider sobre un modelo local de Ollama (el código se queda en tu máquina)

aider --model ollama_chat/qwen3

Para apuntar la misma herramienta a Claude en su lugar (la mejor calidad, el código enviado a la API), configuras tu clave de Anthropic y seleccionas un modelo Claude — el bucle del agente es idéntico; solo cambia el cerebro:

export ANTHROPIC_API_KEY=sk-ant-...
aider --model sonnet

Ese intercambio — una bandera, dos perfiles de privacidad/calidad completamente distintos, el mismo agente — es el propósito entero de esta página.

Compruébate a ti mismo

0/4
  1. ¿Qué significa 'agnóstico respecto al modelo' para un agente de codificación como Aider o Cline?
  2. Tu base de código legalmente no puede salir de tu red. ¿Qué configuración encaja?
  3. ¿En qué se diferencia Claude Code de Aider, Cline, Continue y OpenHands?
  4. ¿Qué herramienta es la más autónoma — construida para tomar una tarea entera y ejecutarla en un sandbox con menos aprobaciones paso a paso?
Pulsa Intro o Espacio para girar la tarjeta. Usa las flechas izquierda y derecha para moverte entre las tarjetas.Término mostrado.
1 / 8
Key takeaways
  • Un agente de codificación ejecuta un bucle en tu máquina — leer el repositorio, planificar, editar archivos, ejecutar pruebas, iterar — en lugar de entregarte fragmentos para pegar.
  • Casi todas estas herramientas son agnósticas respecto al modelo: el agente y el modelo están separados, así que intercambias el cerebro sin cambiar el bucle.
  • Dos diales: Claude para la mejor calidad de código, o un modelo local de pesos abiertos vía Ollama para privacidad total — tu código nunca sale de la máquina.
  • Aider = CLI/git; Cline = agente en tu IDE; Continue = asistente de IDE configurable; OpenHands = autónomo/aislado; Claude Code = el propio agente nativo de Claude de Anthropic.
  • Elige a lo largo de dos ejes — dónde vive el agente (CLI vs IDE vs autónomo) e impulsado por Claude vs totalmente local — y elige el modelo por tarea, no una vez para siempre.

Fuentes y lecturas adicionales​