Tu código revisado por IA antes de cada commit con OpenCode

OpenCode, el agente de IA open source para terminal con más de 120.000 estrellas en GitHub, permite crear pre-commit hooks con IA que entienden el contexto semántico del código — no solo buscan patrones con regex. Con el comando opencode run en modo no-interactivo, cualquier equipo puede montar un hook agéntico que revise cambios antes de cada commit, gratis.

Qué es OpenCode y por qué lo usan millones de desarrolladores cada mes

OpenCode es un agente de IA para la terminal, open source, escrito en Go. Pensalo como un Claude Code pero sin el costo de suscripción: vos traés tu API key del proveedor que quieras y listo. Según su repositorio en GitHub, acumuló más de 120.000 estrellas y una comunidad que no para de crecer desde principios de 2026.

Lo que lo diferencia de alternativas como Aider o el propio Claude Code es la flexibilidad. Soporta más de 75 proveedores de LLM — desde Claude y GPT hasta Gemini, Grok y modelos locales corriendo en Ollama. No te ata a ningún vendor.

El costo real de usar OpenCode es cero. Pagás solamente las llamadas al API del modelo que elijas. Si usás un modelo local, el costo es literalmente nada. Comparalo con Claude Code, que arranca en 20 dólares por mes para el plan más básico.

Pre-commit hooks tradicionales vs. agénticos: la diferencia clave

Un pre-commit hook clásico corre herramientas como ESLint, Prettier, o detect-secrets. Buscan patrones con regex, aplican reglas predefinidas, y rechazan el commit si algo no pasa. Funcionan bien para lo que hacen, pero tienen un techo claro: no entienden qué hace tu código.

Un hook agéntico va más allá. En vez de buscar patrones estáticos, le pasa los archivos modificados a un agente de IA que analiza el cambio en contexto. El agente puede detectar una vulnerabilidad lógica que ningún regex atraparía, advertirte que tu cambio contradice la documentación existente del proyecto, o señalar que estás duplicando funcionalidad que ya existe en otro módulo.

El framework Cluster444/agentic formaliza este concepto con un flujo de cinco fases: Research, Plan, Execute, Commit y Review. Cada fase es un paso discreto donde el agente puede tomar decisiones informadas. La fase de Review, justamente, es donde entraría un pre-commit hook — pero con la capacidad de entender el “por qué” detrás de cada cambio, no solo el “qué”.

OpenCode run: el comando que convierte tu hook en un agente IA

Todo el truco está en opencode run. Este comando ejecuta OpenCode en modo no-interactivo: le pasás un prompt, procesa, y devuelve el resultado. Sin TUI, sin spinners, sin esperar input. Exactamente lo que necesitás para un hook de Git. Si te interesa, podés leer más sobre buenas prácticas de seguridad en GitHub.

Los flags más relevantes para automatización:

• -q — Modo quiet, suprime el spinner y output visual. Fundamental para scripts.
• --model — Elegir qué modelo usar (podés especificar uno rápido y barato para hooks).
• --agent — Seleccionar el agente (plan, build, o uno custom).
• -f json — Output en formato JSON, parseble por otros scripts.
• --continue — Retomar una sesión previa, útil si querés mantener contexto entre runs.

Un ejemplo concreto:

opencode run 'revisá los archivos staged y asegurate de que no haya secretos hardcodeados ni vulnerabilidades obvias' -q -f json

Eso sí: en modo no-interactivo, todos los permisos se auto-aprueban. El agente puede leer archivos, ejecutar comandos, y editar código sin preguntarte. Para un pre-commit hook eso está bien — pero tenelo en cuenta si lo usás en otros contextos.

Implementación paso a paso: pre-commit hook agéntico con OpenCode

Acá va el tutorial completo. Asumí que tenés Git instalado y un proyecto inicializado.

1. Instalar OpenCode

En Linux o macOS:

curl -fsSL https://opencode.ai/install | bash

Verificá que funcione con opencode --version. Si estás en Windows, podés usar WSL o descargarlo desde el repositorio oficial.

2. Configurar el proveedor de modelo

OpenCode busca la configuración en ~/.config/opencode/config.json o en la variable de entorno del proveedor. Si usás Anthropic, basta con exportar ANTHROPIC_API_KEY. Para OpenRouter, OPENROUTER_API_KEY. La lista de proveedores soportados es larga — elegí el que ya tengas.

3. Crear el hook

Creá el archivo .git/hooks/pre-commit con permisos de ejecución:

#!/usr/bin/env bash

set -euo pipefail

STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)

if [ -z "$STAGED_FILES" ]; then

  exit 0

fi

DIFF=$(git diff --cached)

RESULT=$(echo "$DIFF" | opencode run \

  "Analizá este diff. Reportá: 1) secretos hardcodeados, 2) vulnerabilidades de seguridad, 3) errores lógicos obvios. Si encontrás problemas críticos, respondé SOLO con 'BLOCK' en la primera línea seguido de la explicación. Si está todo bien, respondé 'OK'." \

  -q --model anthropic/claude-sonnet-4-20250514 2>/dev/null) Si te interesa, podés leer más sobre herramientas de IA para desarrolladores.

if echo "$RESULT" | head -1 | grep -q "BLOCK"; then

  echo "Pre-commit hook agéntico: problemas detectados"

  echo "$RESULT"

  exit 1

fi

exit 0

Después: chmod +x .git/hooks/pre-commit

4. Ajustes para CI/CD

Si querés usar esto en un pipeline de integración continua, configurá el agente en modo “autoaccept” y usá un modelo rápido para no bloquear el build. Un Haiku o un GPT-4o-mini pueden revisar un diff chico en 3-5 segundos. Para diffs grandes, considerá limitar el análisis a los archivos más críticos.

El Go SDK de OpenCode: integración programática para equipos

Si el script bash se te queda corto, el SDK de Go (v0.19.2, MIT license) te da acceso programático completo. Requiere Go 1.22+ y expone estos servicios principales:

• SessionService — Crear, listar, y gestionar sesiones. Enviar prompts, ejecutar comandos shell, manejar permisos.
• AgentService — Listar agentes disponibles (plan, build, custom).
• FileService — Leer archivos, listar, verificar estado.
• ConfigService — Acceder a configuración de agentes, MCP, proveedores, hooks y formatters.
• EventService — Streaming en tiempo real de más de 20 tipos de eventos (archivo editado, sesión creada, permisos, etc.).

Un ejemplo mínimo en Go para enviar un prompt de revisión:

package main

import (

  "context"

  "fmt"

  opencode "github.com/sst/opencode-sdk-go"

)

func main() {

  client := opencode.NewClient()

  sessions, _ := client.Session.List(context.TODO())

  fmt.Printf("Sesiones activas: %d\n", len(sessions))

}

El SDK fue generado con Stainless a partir de una spec OpenAPI, así que la cobertura del API es completa. Para equipos grandes, esto permite construir herramientas CLI internas que invoquen OpenCode como servicio — ponele, un bot de Slack que revise PRs automáticamente usando el SessionService.

Qué puede detectar un hook agéntico que un linter no puede

Acá viene lo bueno. Casos concretos donde un agente le gana a las herramientas tradicionales:

Vulnerabilidades lógicas. Un linter te avisa si usás eval(). Un agente puede detectar que tu función de autenticación tiene un bypass porque el early return no cubre todos los casos. Eso requiere entender el flujo del programa, no solo buscar tokens.

Doc drift. Tu README dice que la API acepta JSON, pero el handler que acabás de modificar espera form-data. El agente lee ambos archivos y te señala la inconsistencia. Ningún linter hace esto.

Secretos ofuscados. Herramientas como TruffleHog o detect-secrets buscan patrones conocidos (API keys con prefijos estándar, tokens con formato específico). Un agente puede identificar que esa string de 64 caracteres hexadecimales en una constante probablemente sea un secreto, aunque no matchee ningún patrón predefinido. Si te interesa, podés leer más sobre privacidad del código en plataformas como GitHub.

Coherencia arquitectónica. Estás agregando un endpoint nuevo que accede directo a la base de datos, pero el resto del proyecto usa un patrón repository. El agente lo nota.

Ojo: esto no reemplaza a los linters. Los complementa. Un ESLint corre en milisegundos y atrapa errores de sintaxis y estilo. El agente agrega la capa semántica que falta.

Tabla comparativa: herramientas de revisión automática de código en 2026

Limitaciones y trampas comunes al usar IA en pre-commit hooks

No todo es color de rosa. Si vas a implementar esto, tené en cuenta estos problemas reales:

Latencia. Un hook con LLM puede tardar entre 10 y 30 segundos por commit. Si tu equipo hace commits frecuentes y chicos (como debería), eso se siente. Mucho. La solución más práctica es usar un modelo rápido y liviano para el hook, y reservar los modelos grandes para reviews de PR.

Costos de API. Un equipo de 10 developers haciendo 20 commits diarios cada uno son 200 llamadas al API por día. Con Claude Sonnet, eso puede salir entre 2 y 10 dólares diarios dependiendo del tamaño de los diffs. No es una fortuna, pero suma. Con Ollama y un modelo local, el costo cae a cero — aunque la calidad del análisis también baja.

Falsos positivos. El agente va a encontrar “problemas” que no son problemas. Las primeras semanas vas a tener alert fatigue hasta que ajustes el prompt. Sé específico en lo que le pedís que busque — “detectá secretos hardcodeados y SQL injection” funciona mejor que “revisá todo”. Si te interesa, podés leer más sobre diferencias entre las plataformas de Microsoft y GitHub.

Dependencia de conexión. Si usás un modelo en la nube y se cae internet, tu hook falla y no podés commitear. Solución: agregá un timeout y un fallback que deje pasar el commit con un warning.

Dicho esto, la cosa es que los devs pueden bypassear cualquier hook con git commit --no-verify. Un hook no es un control de seguridad — es una red de contención. Si tu equipo lo skipea sistemáticamente, el problema no es el hook.

OpenCode en el ecosistema 2026: extensibilidad y herramientas complementarias

Según un análisis detallado de su arquitectura de extensibilidad, OpenCode ofrece seis mecanismos para personalizar su comportamiento: plugins MCP, agentes custom, configuración de proveedores, hooks experimentales, formatters y watchers. Eso lo hace mucho más flexible que herramientas cerradas.

El sistema de agentes es particularmente interesante. OpenCode viene con agentes predefinidos — plan (para exploración segura, solo lectura) y build (para modificar código) — pero podés definir los tuyos. Un agente custom de “security review” que solo busque vulnerabilidades OWASP es perfectamente viable.

El punto es que OpenCode no compite solo. Se complementa con herramientas que cubren otros eslabones de la cadena:

• CodeRabbit — Revisión automatizada de PRs en GitHub y GitLab. Es la app de IA más instalada en ambas plataformas para code review.
• SonarQube — Análisis estático de seguridad (SAST). Ideal para reglas de compliance que no cambian.
• Snyk — Escaneo de dependencias con vulnerabilidades conocidas.
• El framework Cluster444/agentic — Estructura workflows de desarrollo en cinco fases, donde cada fase puede invocar agentes diferentes.

Para equipos que hosteen sus propios runners de CI/CD — en un VPS de donweb.com, por ejemplo — la combinación de OpenCode en pre-commit + CodeRabbit en PR + SonarQube en pipeline cubre prácticamente todas las capas de revisión automática.

Errores comunes al implementar hooks agénticos

Usar el modelo más caro “porque es mejor”. Para un pre-commit hook no necesitás Claude Opus ni GPT-4o. Un Haiku o un modelo local chico puede revisar un diff de 200 líneas perfectamente. Guardá los modelos pesados para tareas que realmente los justifiquen.

No poner timeout. Si el API del modelo tarda más de lo esperado o directamente no responde, tu hook se cuelga indefinidamente y el developer queda trabado. Siempre poné un timeout de 30-60 segundos con fallback a exit 0. Si te interesa, podés leer más sobre montar un servidor local para desarrollo.

Pedirle al agente que revise “todo”. Un prompt vago genera respuestas vagas. “Revisá este código” te va a devolver observaciones genéricas sobre naming conventions y comentarios faltantes. Sé quirúrgico: “buscá SQL injection, secretos hardcodeados y race conditions” da resultados útiles.

No cachear resultados. Si un developer hace git commit --amend sin cambiar archivos, el hook vuelve a analizar todo. Podés agregar un cache basado en el hash del diff para evitar llamadas redundantes al API.

Preguntas Frecuentes

¿Cómo instalar y configurar OpenCode para usarlo en hooks de Git?

Instalás con curl -fsSL https://opencode.ai/install | bash, configurás tu API key como variable de entorno (por ejemplo ANTHROPIC_API_KEY), y creás un script en .git/hooks/pre-commit que invoque opencode run con el prompt que necesites. Dale permisos de ejecución con chmod +x y listo.

¿Qué ventajas tiene un pre-commit hook con IA frente a linters tradicionales?

El agente entiende contexto semántico: puede detectar vulnerabilidades lógicas, inconsistencias con la documentación, y problemas arquitectónicos que un linter basado en regex jamás atraparía. No reemplaza al linter — le agrega una capa de análisis que antes solo podía hacer un humano en code review.

¿El SDK de Go de OpenCode permite crear herramientas personalizadas de revisión?

Sí. El SDK (v0.19.2, Go 1.22+) expone servicios como SessionService para enviar prompts, FileService para leer archivos, y EventService para streaming de eventos. Podés construir herramientas CLI internas que usen OpenCode como backend de análisis, integrándolo en bots de Slack, dashboards internos, o pipelines custom.

¿Cuánto cuesta usar OpenCode como pre-commit hook en un equipo?

OpenCode en sí es gratuito. El costo depende del modelo que uses y la cantidad de commits. Un equipo de 10 personas con un modelo cloud como Claude Sonnet puede gastar entre 2 y 10 dólares por día. Con un modelo local vía Ollama, el costo es cero — sacrificando algo de calidad en el análisis.

Conclusión

Los pre-commit hooks con IA no son ciencia ficción — son un script bash de 15 líneas y una llamada a opencode run. La barrera de entrada bajó a prácticamente cero gracias a herramientas open source como OpenCode, que te dejan elegir modelo, proveedor, y nivel de análisis sin atarte a ningún servicio pago.

El cambio real acá es pasar de “¿este código tiene errores de sintaxis?” a “¿este cambio tiene sentido en el contexto del proyecto?”. Eso es lo que hace un hook agéntico: no reemplaza al linter, le agrega la capa de comprensión que antes solo existía en el code review manual. Si tenés un equipo que ya usa Git hooks, agregar un agente de IA al flujo es cuestión de media hora. Si no los usás, quizás sea buen momento para empezar.

Fuentes

• OpenCode – Repositorio oficial en GitHub
• OpenCode CLI – Documentación oficial del modo no-interactivo y comando run
• OpenCode Go SDK – Documentación del paquete en pkg.go.dev
• Does OpenCode Support Hooks? A Complete Guide to Extensibility – Dev.to
• Cluster444/agentic – Framework de workflows agénticos en GitHub