OpenCodex Blog

Publicación

- 8 min read

Qué aprender en 2027: agentes de IA, no otro framework

img of Qué aprender en 2027: agentes de IA, no otro framework

Disclaimer: no soy la persona que predice el mercado. Soy un desarrollador backend que lee ofertas de trabajo, recibe rechazos y se ajusta al mercado. Así que toma esto como notas o guía, no como un pronóstico.

Pero hay una cosa de la que sí estoy seguro, porque la viví este año, lo difícil de mi trabajo dejó de ser escribir el código. Lo difícil es leer a velocidad lo que escribió un agente y saber si está bien.

Esa es la habilidad que merece la pena aprender en 2027.

Qué cambió de verdad

Hace dos años el cuello de botella era codear. Sabías lo que querías, producirlo tomaba horas. Los agentes comprimieron eso a minutos.

El cuello de botella se movió. Ahora un modelo produce una solución en cuarenta segundos, y tú tienes quizá tres minutos para decidir si es correcta, legible, segura y coherente con el resto de tu código. Si no puedes hacer eso, el agente no te hizo más rápido. Te hizo más riesgoso y te dio más trabajo.

Por eso “aprende a hacer prompts” es un mal consejo. El prompting se aprende en días. Revisar código generado es una habilidad que se aprende en años, y se construye sobre los fundamentos que todos te dicen que saltes: estructuras de datos, complejidad, cómo ejecuta realmente una consulta tu base de datos, cómo funciona TCP, cómo falla un proceso a las 3 de la mañana.

Un agente te va a escribir una función que hace un recorrido lineal dentro de un bucle y parece perfectamente razonable. Si no sabes por qué eso es O(n²), la subes a producción.

Las cinco cosas en las que me enfocaría

1. Fundamentos, pero por un motivo distinto. No para escribir código de memoria, sino para auditar código que no escribiste. Es un ejercicio diferente. Leer EXPLAIN ANALYZE importa más que nunca, porque el agente no lo va a ejecutar por ti con criterio.

2. Linux y la terminal, en serio. Los agentes viven en tu shell. Ejecutan comandos, leen archivos, lanzan procesos. Los desarrolladores que más partido les sacan son los que ya sabían cuál debía ser el comando. Si no sabes depurar un servicio que no arranca, la explicación segura del agente te va a convencer de lo incorrecto.

3. Un agente, bien configurado. No cinco instalados y medio usados. La diferencia entre una configuración mediocre y una buena no es el modelo. Es el contexto: qué sabe de tu proyecto, qué puede leer, qué tiene permitido hacer y si recuerda lo de ayer.

4. MCP, y cómo llegan las herramientas a un modelo. El Model Context Protocol es cómo un agente habla con tu base de datos, tu navegador, tu documentación. Aprender a conectar una herramienta bien te enseña más sobre agentes que diez tutoriales.

5. Verificación. Tests, diffs, reproducciones. Aquí está todo el juego. Un agente que no puede probar lo que hizo es una suposición bien maquetada. Y es también lo que te hace contratable, porque es lo difícil de fingir.

Lo que dejaría de hacer

  • Coleccionar frameworks. Otro meta-framework de JavaScript en 2027 es mercancía. Nadie te contrata por eso en concreto.
  • Ver contenido de “IA para desarrolladores” sin construir nada. Yo lo hice durante semanas. Es entretenimiento.
  • Aprender herramientas que solo funcionan dentro del IDE de un fabricante. Prefiere herramientas que corren en tu terminal y son dueñas de tus archivos.

La configuración que uso de verdad

Yo corro OpenCode v2, configurado con Gentle-AI. Te explico el razonamiento y luego la instalación exacta.

Por qué OpenCode. Es open source, corre en la terminal, no está atado a un solo proveedor de modelos y se extiende con agentes, skills, comandos, plugins y servidores MCP. Si estás en Linux y vives en una terminal, esa combinación es difícil de superar. También tiene app de escritorio e interfaz web, si las quieres.

Por qué Gentle-AI encima. Un agente sin flujo de trabajo olvida todo entre sesiones, no tiene opinión sobre tu proyecto y no puede probar lo que hizo. Gentle-AI le añade tres cosas: memoria persistente (Engram), un flujo para cómo se hace el trabajo (ODD) y un paso de revisión basado en evidencia (RDD). También le da a tu agente una biblioteca grande de skills que se cargan bajo demanda.

Importante, y el proyecto lo dice con claridad: Gentle-AI nunca te instala un agente de IA. Configura el que ya tienes. Es un buen diseño, y conviene saberlo antes de empezar.

Instalar OpenCode

Elige un método.

   # curl (recomendado en Linux)
curl -fsSL https://opencode.ai/v2/install | bash
   # Homebrew
brew install anomalyco/tap/opencode-v2
   # npm
npm install -g @opencode/cli
   # pnpm
pnpm add -g --allow-build=@opencode/cli @opencode/cli

En Arch también hay paquete en AUR, paru -S opencode-beta, que sigue el canal beta.

   sudo pacman -S opencode

Compruébalo:

   opencode --version

La primera ejecución abre la interfaz de terminal. Antes de preguntarle nada, conecta un modelo:

   /connect

Eso abre el selector de proveedores. Puedes llevar tu propia clave de API o usar un plan de suscripción. No te saltes esto y luego te preguntes por qué el agente no hace nada.

Instalar Gentle-AI

   # macOS / Linux, instalador por script
curl -fsSL https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.sh | bash
   # Homebrew
brew install gentleman-programming/tap/gentle-ai
   # desde el código fuente, necesita Go
go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest

Si usas go install, el binario queda en $(go env GOPATH)/bin, que no está en tu PATH por defecto. Añádelo una vez y abre una terminal nueva:

   echo "export PATH=\"$(go env GOPATH)/bin:\$PATH\"" >> ~/.bashrc

Después lanza la interfaz del instalador:

   gentle-ai

Interfaz del instalador de Gentle-AI seleccionando agentes y componentes

Pregunta tres cosas: qué agentes configurar, qué componentes instalar y qué persona aplicar. No necesitas Claude Code, Codex y Cursor a la vez. Empieza por OpenCode.

Si prefieres banderas en lugar de la interfaz, o quieres ver el plan antes de aplicarlo:

   gentle-ai install --agent opencode --dry-run

--dry-run imprime el plan y no toca nada. Úsalo la primera vez. Cuando el plan te convenza, quita la bandera.

Luego verifica. doctor es de solo lectura; no cambia nada:

   gentle-ai doctor

Salida de gentle-ai doctor

De vuelta en OpenCode, el agente ya tiene memoria, flujo de trabajo y un paso de revisión. Además guarda una copia de tu configuración antes de cada escritura que hace, lo cual importa la primera vez que rompas algo.

Actualizar los dos

Son dos cosas independientes que hay que mantener al día.

OpenCode se actualiza solo:

   opencode upgrade

Detecta cómo lo instalaste. Si lo instaló un gestor de paquetes que controla la versión, pásale el método explícito, por ejemplo opencode upgrade --method brew.

Gentle-AI depende de cómo lo instalaste:

   # Homebrew
brew upgrade gentle-ai
   # instalador por script — vuelve a ejecutarlo
curl -fsSL https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.sh | bash
   # desde el código fuente
go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest

Actualizar el binario no es el último paso. Las configuraciones y skills gestionadas tienen que coincidir con la versión nueva:

   gentle-ai sync

sync reescribe los archivos gestionados, respeta tu configuración propia y deja una copia de seguridad. Después, vuelve a ejecutar gentle-ai doctor. Si actualizas solo el binario y te saltas sync, acabas con un CLI nuevo leyendo prompts viejos, que es el tipo de problema que parece un fallo del modelo y no lo es.

   gentle-ai --version
opencode --version

Cómo se ve una sesión

   cd ~/projects/tu-app
opencode

Sesión de OpenCode en la terminal trabajando sobre un repositorio

La diferencia con una ventana de chat es que el agente lee tu repositorio, ejecuta tus comandos y edita archivos. Que es exactamente por lo que la siguiente parte importa.

La parte que nadie pone en el anuncio

Un agente con permiso de escritura y sin verificación es una forma muy rápida de introducir bugs que no vas a notar hasta dentro de un mes. La primera semana que usé uno, acepté un refactor que no pasaba ningún test, porque no había tests que pasar.

Así que el flujo que yo aprendería en 2027, en una línea: haz que el agente lo demuestre.

  • Si el cambio se puede testear, escribe el test primero y míralo fallar. Un agente que nunca ve un test rojo te va a entregar contento uno verde que no prueba nada.
  • Lee el diff. Entero. No el resumen.
  • Ejecuta tú mismo el comando en el caso raro que el agente no consideró.
  • Si dice “esto debería funcionar”, eso no es evidencia.

No es una limitación de las herramientas. Es el trabajo ahora.

Un plan de 90 días, si quieres uno

Días 1 a 15. Instala OpenCode y Gentle-AI. Úsalos en un proyecto real, no en un tutorial. Rompe algo y arréglalo.

Días 16 a 45. Escoge algo que ya domines y haz que el agente lo haga, luego revisa el resultado línea por línea. Vas a encontrar algo. Ese momento es la habilidad.

Días 46 a 75. Añade un servidor MCP que conecte el agente con algo que uses de verdad. Lee cómo funciona, no solo cómo se instala.

Días 76 a 90. Escribe tu configuración. Un post corto, un README, un repo de dotfiles. Explicar tu flujo es cómo descubres qué partes de él son reales.

El resumen honesto

En 2027, “sé React” no diferencia a nadie. “Sé dirigir un agente para construir algo y probar que funciona” sí, porque exige todo lo de debajo: fundamentos, Linux, testing, criterio.

Las herramientas van a cambiar. Este post va a estar desactualizado antes de que termine el año, y está bien. El flujo que describe, memoria, pasos pequeños, evidencia, es la parte que sobrevive.

Si te llevas una sola cosa, llévate la frase del README de Gentle-AI a la que vuelvo una y otra vez: verificar gana a generar.