OpenCode: cuando la IA no viene a reemplazarte, sino a amplificarte
Últimamente he visto a varios colegas preocupados porque la IA nos va a dejar sin trabajo. Es una conversación que aparece en redes sociales, en grupos de WhatsApp, en la hora del café. Y lo entiendo: ver lo que hacen modelos como Claude, GPT o Gemini hoy puede ser impresionante, y hasta preocupante si lo ves por primera vez.
Quiero iniciar diciendo que no soy un experto en IA, ni pretendo tener la verdad absoluta. Pero después de varios meses usando estas herramientas a diario —no para experimentar, sino como parte de mi flujo de trabajo real— he llegado a una conclusión distinta: la IA no viene a reemplazarnos. Viene a amplificarnos.
El verdadero problema no es la IA
El problema real que enfrentamos como programadores no es que la IA nos quite el trabajo. Es que seguimos gastando tiempo valioso en tareas mecánicas que un asistente bien configurado podría hacer por nosotros:
- Ejecutar linters, type checkers y tests antes de cada commit.
- Recordar el formato exacto de un conventional commit.
- Revisar si hay secretos o tokens expuestos en el código.
- Escribir la misma estructura de Dockerfile una y otra vez al iniciar un proyecto.
- Recordar cómo configurar correctamente un proyecto con un framework específico.
Nada de esto es particularmente difícil. Es simplemente tedioso. Y lo más frustrante es que cuando nos saltamos algún paso por prisas, lo descubrimos en CI, no antes.
Ahí es donde la IA, bien usada, deja de ser una amenaza y se convierte en una herramienta poderosa.
OpenCode: agentes, no chats
OpenCode es una herramienta que te permite crear agentes de IA especializados para diferentes tareas de programación. No es solo un chat con un modelo: es un sistema donde defines agentes con roles, permisos, prompts y skills, y ellos trabajan juntos para resolver problemas de principio a fin.
La idea clave es esta: tú decides el qué (la dirección, la arquitectura, las decisiones importantes). Los agentes se encargan del cómo (la ejecución, las revisiones, el código repetitivo).
Tu experiencia como programador no se vuelve obsoleta. Se vuelve el ingrediente más importante de la receta. Puedes revisar la documentación oficial para conocer todas las opciones de configuración.
Arquitectura: un agente principal que orquesta
La configuración que he construido tiene un agente principal (coder) y varios sub-agentes especializados. El flujo es más o menos así:
- Le pido al agente principal que implemente una funcionalidad.
- El agente carga los skills relevantes para el contexto (el framework, las herramientas, las convenciones del proyecto).
- Para funcionalidades no triviales, primero escribe un spec técnico antes de tocar código.
- Escribe el código siguiendo las mejores prácticas definidas en los skills.
- Automáticamente delega en el sub-agente de calidad para que ejecute linters, type checkers y pruebas.
- Si hay errores, los corrige y vuelve a pasar calidad.
- Una vez que calidad pasa, delega en el sub-agente de seguridad para revisar vulnerabilidades y secretos expuestos.
- Reporta todo de vuelta: qué se hizo, qué se encontró, qué decisiones se tomaron.
Cada sub-agente tiene un prompt especializado y una temperatura baja para ser consistente y predecible. Y lo más importante: los sub-agentes solo pueden leer archivos y ejecutar comandos —no pueden modificar código sin mi aprobación.
La configuración se ve más o menos así en opencode.json:
{
"agent": {
"coder": {
"mode": "primary",
"prompt": "...",
"color": "success"
},
"quality": {
"mode": "subagent",
"temperature": 0.1,
"permission": {
"read": "allow",
"edit": "deny",
"bash": "allow"
}
},
"security": {
"mode": "subagent",
"temperature": 0.1,
"permission": {
"read": "allow",
"edit": "deny",
"bash": "allow"
}
},
"versioning": {
"mode": "subagent",
"temperature": 0.1,
"permission": {
"read": "allow",
"edit": "deny",
"bash": "allow"
}
}
}
}
El prompt del agente principal define el workflow completo. El de calidad sabe exactamente qué herramientas ejecutar según el lenguaje del proyecto. El de seguridad sabe buscar vulnerabilidades, secretos en git y configuraciones incorrectas en Docker. El de versioning analiza los cambios y sugiere un commit convencional.
Sub-agentes: prompts especializados con frontmatter
Para agentes con lógica no trivial, la recomendación es definirlos en archivos separados. Cada agente se guarda en .opencode/agents/<nombre>.md con frontmatter YAML que declara sus metadatos, y el cuerpo del archivo es su prompt:
---
description: Runs linters, type checkers, and tests to verify code quality
mode: subagent
temperature: 0.1
permission:
read: allow
edit: deny
bash: allow
---
You are the quality assurance sub-agent.
1. Run ruff check for linting issues.
2. Run mypy for type errors (if a config exists).
3. Run pytest for test failures.
Summarize findings clearly. Do NOT edit files.
Report results to the calling agent.
El frontmatter define el modo (subagente), la temperatura y los permisos. El cuerpo es el prompt que el agente sigue al pie de la letra. Esta separación permite tener agentes reutilizables, con permisos granulares y comportamientos predecibles. La guía de OpenCode para escribir agentes explica el formato frontmatter en detalle.
Skills: tu conocimiento empaquetado
Los skills son archivos Markdown que le dan contexto al agente sobre tecnologías específicas. Piensa en ellos como guías de referencia que el agente consulta cuando detecta que el proyecto usa ciertas herramientas.
También usan frontmatter con name y description para que OpenCode los descubra automáticamente:
---
name: fastapi
description: FastAPI patterns, gotchas, and best practices — including Pydantic v2, dependencies, lifespan, and middleware.
---
# FastAPI
## Estructura de proyecto recomendada
- app/ con main.py, routers/, models/, schemas/
- Configuración con Pydantic Settings
- Dependencias en app/dependencies/
## Patrones
- Usar dependency injection para autenticación
- Modelos SQLAlchemy en models/, esquemas Pydantic en schemas/
- Lifespan para startup/shutdown (no eventos)
Lo interesante es que estos skills los escribes tú, con tu experiencia y criterio. No son recetas genéricas de internet: son tu conocimiento empaquetado para que la IA lo aplique consistentemente.
Si quieres explorar skills listos para usar, skills.sh es un directorio comunitario con cientos de skills compatibles con OpenCode. Ahí puedes encontrar desde best practices para frameworks hasta skills de testing, seguridad y más. También puedes consultar la documentación de OpenCode sobre skills para entender cómo cargarlos desde URLs o directorios personalizados.
No necesitas pagar para empezar
Una de las cosas que más me gusta de OpenCode es que no necesitas pagar para probarlo. OpenCode Zen es la versión gratuita, e incluye acceso a modelos muy capaces como DeepSeek v4 Flash Free.
Puedes aprender el flujo completo, crear tus skills, ajustar tus prompts, afinar tu workflow —todo sin soltar un centavo. Y cuando quieras más potencia, escalas a OpenCode Go o conectas tus propios proveedores como Claude, GPT o Gemini.
Lo mejor de todo es que el trabajo que inviertes en crear agentes y skills es completamente portable entre proveedores. Cambias de modelo, pero tu configuración y conocimiento siguen siendo tuyos.
No necesitas el modelo más grande ni el más caro para empezar a ser más productivo. Un agente bien configurado con un modelo gratuito rinde más que el mejor modelo del mundo usado sin dirección.
Lo que aprendí
Si algo aprendí en este proceso es que mientras más específico sea tu conocimiento plasmado en prompts y skills, mejores resultados obtienes. La IA no es magia. Es un multiplicador de tu experiencia.
Lo que salió bien: La separación de responsabilidades entre agentes. Que el de calidad tenga temperatura baja garantiza resultados consistentes y predecibles. Los skills me permitieron estandarizar buenas prácticas entre proyectos sin tener que recordarlas cada vez.
¿Un camino terminado? Para nada. Esto es un punto de partida. Cada proyecto me revela algo que ajustar: cómo mejorar los prompts, qué skills faltan, dónde conviene automatizar más y dónde es mejor mantener supervisión directa. El workflow sigue evolucionando con cada uso.
Al final del día, el factor diferenciador no es el modelo de IA que uses. Es cómo lo usas, qué prompts escribes, qué skills defines, cómo orquestas los agentes. Todo eso depende de tu criterio como programador.
Para cerrar
La IA no viene a reemplazarte. Viene a quitarte el trabajo tedioso para que puedas concentrarte en lo que realmente importa: diseñar arquitecturas, tomar decisiones técnicas, crear soluciones.
Invertir tiempo hoy en aprender a usar estas herramientas es una decisión profesional que te va a diferenciar mañana. No importa si empiezas con OpenCode Zen y DeepSeek, o si prefieres ir directo con Claude. Lo importante es empezar.
Gracias por llegar hasta aquí. Nos vemos en el próximo post.
