NBLM Toolkit for NotebookLM
13-¿Tu código se revisa mientras duermes? Cómo la dupla Claude-Hermes está redefiniendo el flujo de trabajo dev
Basado en 1 fuente
Exportado desde el visor de artefactos abierto actualmente en NotebookLM.
Basado en 1 fuente
Cuaderno: Hermes Agent: Guía Completa de Ingeniería de Harness Automatizada
¿Tu código se revisa mientras duermes? Cómo la dupla Claude-Hermes está redefiniendo el flujo de trabajo dev
1. El fin de la "resaca" de los lunes por la mañana
Es lunes, 9:00 AM. Abres tu laptop esperando la clásica "resaca" de fin de semana: una montaña de notificaciones, solicitudes de revisión (PRs) acumuladas y el temor a que algo se haya roto en el CI mientras no estabas. Sin embargo, en lugar de ese caos, te recibe una serie de mensajes en Telegram. No son de un colega madrugador, sino de Hermes:
- "Anoche a las 11:17 PM se fusionó un PR en main (387 líneas nuevas). Lo revisé y encontré dos problemas: la lógica de expiración de tokens en el módulo de auth no maneja un caso de borde y la cobertura de pruebas bajó del 82% al 76%."
- "A las 2:40 AM, el pipeline de CI ejecutó la suite de regresión. Fallaron 3 casos: 2 introducidos por el PR de ayer y 1 que es un 'flaky test' ya conocido."
- "He redactado las notas para el standup diario basadas en tus 4 commits y 2 PRs de ayer. Solo necesitan tu aprobación."
La automatización ha dejado de ser una simple colección de scripts reactivos. Estamos ante la madurez de los agentes autónomos persistentes. En este ecosistema, Claude Code y Hermes Agent no son competidores; son una simbiosis perfecta donde uno construye con precisión quirúrgica y el otro vigila incansablemente.
--------------------------------------------------------------------------------
2. El "Artesano" y el "Mayordomo": Una división de tareas revolucionaria
Para un estratega de automatización, intentar que una sola IA gestione todo el flujo es un error táctico. La especialización existe porque los disparadores (triggers) y la naturaleza del cómputo son distintos. Claude Code es el artesano de alta intensidad; Hermes es el vigilante de largo aliento.
Dimensión | Claude Code (El Artesano) | Hermes Agent (El Mayordomo) |
|---|---|---|
Modo de interacción | Conversación en tiempo real, presencial. | Segundo plano, reportes programados. |
Fortalezas | Escritura, refactorización y depuración. | Monitoreo, auditoría, síntesis y agenda. |
Horizonte temporal | Sesión única, tarea específica. | Continuo (días y semanas). |
Activador (Trigger) | Iniciado manualmente por el usuario. | Cron o eventos de sistema (GitHub). |
Análisis: No le pedirías al artesano que hiciera la "guardia nocturna" ni al mayordomo que pusiera los ladrillos. Claude está optimizado para ráfagas de creatividad técnica de alto nivel, mientras que Hermes brilla en la persistencia y el contexto de larga duración. Como bien se define en el sector:
"Claude Code es el artesano, Hermes es el mayordomo. El artesano construye cosas; el mayordomo se asegura de que todo se mantenga en el camino correcto".
--------------------------------------------------------------------------------
3. Adiós a las reglas estáticas: Estándares de revisión que "viven"
Las revisiones de código tradicionales sufren de latencia e inconsistencia. Hermes soluciona esto mediante "Skills" (Habilidades) que reemplazan al linting estático. Para configurar este flujo, seguimos tres pasos fundamentales:
- Conectar GitHub MCP: Se configura el servidor GitHub MCP en el
config.yaml, permitiendo que Hermes acceda a PRs, diffs e issues con contexto completo. - Configurar Cron: En lenguaje natural, le instruyes: "Revisa la rama principal en busca de nuevos PRs cada 6 horas y realiza una revisión de código". Hermes genera el trabajo programado automáticamente.
- Definir Estándares de Revisión: Aquí es donde los estándares "cobran vida". En lugar de reglas rígidas, defines una Skill con criterios como: "Las funciones deben tener menos de 50 líneas", "El manejo de errores debe usar tipos personalizados" o "Todos los endpoints de la API deben tener pruebas".
A diferencia de un linter tradicional, estos estándares evolucionan. Si Hermes pasa algo por alto y tú lo señalas, el agente aprende ese patrón y lo integra en su vigilancia perpetua.
--------------------------------------------------------------------------------
4. Pruebas proactivas: Cuando la IA no espera órdenes
Claude Code es excelente escribiendo pruebas bajo demanda ("escribe un test para esto"). Sin embargo, Hermes cambia el modelo a uno proactivo: él descubre qué falta.
Hermes utiliza una arquitectura de herramientas coordinadas:
- file: Escanea la base de código para identificar módulos huérfanos de pruebas.
- code_execution: Ejecuta las pruebas en un sandbox seguro para verificar resultados.
- terminal: Genera reportes técnicos detallados, como los escaneos de cobertura automáticos que realiza cada lunes por la mañana.
- memory: Su activo más valioso; recuerda qué módulos han sido auditados y qué tests son inestables (flaky), evitando falsos positivos.
Esta "detección de lagunas" autónoma es lo que garantiza la estabilidad a largo plazo, liberando al desarrollador de la auditoría manual constante.
--------------------------------------------------------------------------------
5. De registros de commits a narrativas con causa y efecto
La mayoría de los historiales de Git son una lista fría de cambios. Gracias a su memoria de sesión cruzada, Hermes transforma esto en una narrativa técnica.
Hermes puede conectar los puntos del "arco completo de la semana": entiende que el bug que corregiste el lunes fue la razón por la que cambiaste el plan arquitectónico el miércoles, y por qué eso causó que el PR del viernes fuera rechazado. No es solo un log; es una explicación de las decisiones técnicas.
Pro Tip: Para maximizar esto, instruye a Hermes para que, al generar su reporte diario, actualice una "Skill de Proyecto" con las decisiones técnicas clave. Así, al redactar el reporte semanal, referenciará hechos concretos en lugar de "adivinar tus intenciones basándose en mensajes de commit vagos".
--------------------------------------------------------------------------------
6. La advertencia necesaria: El factor humano no es negociable
A pesar de la autonomía de Hermes, un estratega sabe dónde trazar la línea. La IA es un suplemento extraordinario para capturar errores basados en patrones, pero no es un sustituto del criterio senior.
Las decisiones arquitectónicas de alto nivel y la visión del sistema siguen requiriendo el ojo humano. Hermes detectará inconsistencias en nombres o casos de borde omitidos, pero no debe decidir la estructura core de tu aplicación. Es imperativo mantener al humano en el flujo (Human-in-the-loop), especialmente en módulos críticos.
--------------------------------------------------------------------------------
7. Conclusión: Tu nuevo enfoque como desarrollador
Estamos migrando hacia un pipeline de cuatro etapas automatizadas: Claude escribe/abre PR Hermes revisa Hermes prueba y verifica Hermes reporta.
Con este flujo, tu enfoque cambia radicalmente de "escribir + revisar + probar + reportar" a simplemente "escribir + confirmar resultados". Todo lo que ocurre en medio queda bajo la supervisión del "Mayordomo de IA".
Al delegar esta burocracia técnica, recuperamos entre un 30% y un 40% de nuestro tiempo productivo. La pregunta para el desarrollador moderno ya no es cómo automatizar, sino qué hará con ese tiempo extra ahora que ya no tiene que ser el vigilante nocturno de su propio código.