Saltar a contenido

Hotfix Fast Track

Esta guía está pensada para entender qué hace el asistente de IA cuando ejecuta este playbook. La idea es que puedas leerla, entender qué pasa en cada paso, y saber qué información tenés que darle al asistente para que el trabajo salga bien.

En resumen

  • Para qué sirve: confirmar en minutos, no en horas, si un arreglo urgente (hotfix) ya aplicado es seguro para liberar a producción.
  • Cuándo usarlo: cuando el arreglo ya está hecho y desplegado, en una rama hotfix/* o con un ticket marcado como hotfix, y no hay tiempo para un ciclo completo.
  • Qué necesitás: una batería mínima de pruebas críticas ("smoke") del módulo, la descripción de lo corregido, el plan de pruebas de la historia y el qa-stack.yaml del proyecto.
  • Qué te llevás: un veredicto claro (liberar o frenar), una prueba que vigila el arreglo y un reporte con fecha y hora.
  • Pasos: 3, más un pre-chequeo — confirmar que existe la smoke, ejecutarla como semáforo, dejar una prueba de regresión y generar el reporte.
¿Qué es un playbook? (si es la primera vez que usás uno)

Pensalo como una receta de cocina para el asistente de IA. Vos le decís "quiero hacer esto" (por ejemplo, "quiero validar este arreglo urgente antes de liberarlo") y el playbook es la receta que el asistente sigue paso a paso, en orden, sin saltarse nada, para que el resultado sea siempre el mismo sin importar quién lo pida.

Cada paso de la receta usa una herramienta puntual (en la jerga técnica se las llama "skills"), algo así como un utensilio de cocina: uno sirve para pelar, otro para cortar, otro para hornear. Vos no necesitás saber cómo funciona cada utensilio por dentro — solo necesitás saber qué ingrediente hay que poner en cada paso (por ejemplo, qué se corrigió, o en qué URL está desplegado el arreglo) para que el plato final salga bien.

Un playbook = una guía ordenada de pasos. Una skill = la herramienta puntual que ejecuta cada paso. Interactuás con el playbook — el asistente se encarga de usar la herramienta correcta en cada momento.


1. ¿Qué hace este playbook?

Es el playbook que usás cuando ya existe un arreglo urgente aplicado (un "hotfix") y necesitás confirmar en minutos, no en horas, si es seguro liberarlo a producción.

Es importante entender la diferencia con otros playbooks: acá el arreglo ya está hecho. El foco no es acompañar al developer a corregir el bug (para eso existe el playbook Bug Fix Cycle) — el foco es validar rápido que ese arreglo funciona y que no rompió nada crítico, para poder decidir en el momento: ¿se libera o no se libera?

Para lograr esa velocidad, este playbook no revisa toda la aplicación de punta a punta. En cambio:

  1. Ejecuta únicamente un conjunto mínimo de pruebas críticas ya existente (la "smoke" — las pruebas de las funciones más importantes de ese módulo, como quien revisa solo los frenos y las luces de un auto antes de salir a la ruta, no el auto entero).
  2. Actúa como un semáforo automático: si esas pruebas críticas pasan, da luz verde para avanzar; si alguna falla, frena todo de inmediato.
  3. Si dio luz verde, deja guardada una prueba automática puntual que en el futuro va a vigilar que ese arreglo específico no se rompa de nuevo.
  4. Escribe un reporte con el resultado y la fecha exacta, para que quede registro de que el hotfix fue validado antes de salir. Lo importante (el semáforo, si se guardó la prueba y la recomendación de liberar o no) queda arriba de todo, para leerlo en un minuto.

Al terminar, el hotfix queda con:

  • Un veredicto claro: aprobado para liberar o freno total con el motivo documentado.
  • Una prueba automática nueva que protege ese arreglo puntual hacia el futuro (si el tiempo lo permitió).
  • Un reporte con fecha y hora, que sirve como respaldo de que el hotfix no se liberó "a ciegas".

2. ¿Cuándo tengo que usar este playbook?

Usalo cuando estés frente a alguna de estas situaciones:

Situación Ejemplo de negocio
Hay un arreglo urgente ya aplicado y hace falta subirlo a producción cuanto antes Un cliente de TechStore descubre un viernes a la tarde que, al aplicar un cupón de descuento válido en el checkout, el total no se recalcula — el cliente termina pagando de más. Un developer ya aplicó el arreglo y está esperando el OK para liberarlo.
No hay tiempo para un ciclo completo de prueba (reproducir, escribir prueba en rojo, esperar el fix, verificar en verde) El equipo de TechStore necesita liberar el arreglo del checkout antes de que arranque el pico de tráfico del viernes a la noche — no hay margen para un ciclo largo.
Se necesita un "semáforo" automático antes de aprobar el release El líder de QA de TechStore no quiere aprobar el release del hotfix "de palabra" — quiere que un conjunto mínimo de pruebas críticas confirme que nada esencial se rompió.
El ticket o la rama ya están marcados como hotfix El developer subió el arreglo a una rama llamada hotfix/checkout-discount o el ticket tiene la etiqueta hotfix.

Importante

  • Este playbook necesita que ya exista un conjunto mínimo de pruebas críticas ("smoke") para el módulo afectado, guardado en su propia carpeta smoke/ dentro de las pruebas del módulo. Si no existe ninguna, el playbook se detiene de inmediato y no continúa — primero hay que crear al menos una prueba crítica para ese módulo. Esto es no negociable: sin esa red de seguridad mínima, no se puede garantizar que el hotfix sea seguro.
  • Este playbook asume que el arreglo ya está aplicado y desplegado. Si el bug todavía no fue corregido, no es este playbook — es el playbook Bug Fix Cycle, que sí acompaña todo el proceso de corregirlo.
  • Este playbook está pensado específicamente para una rama hotfix/* o un ticket con el label hotfix. Si el arreglo no está en ese contexto, tampoco es este playbook — de nuevo, corresponde Bug Fix Cycle.
  • Es un playbook pensado para la urgencia: prioriza velocidad por sobre cobertura exhaustiva. No reemplaza una regresión completa cuando sí hay tiempo disponible.
  • Si el proyecto todavía no tiene la configuración básica de QA automatizado (el archivo qa-stack.yaml), primero hay que ejecutar el playbook de puesta en marcha del proyecto.

3. Ejemplo guía: "TechStore", una tienda online con carrito de compras

Vamos a seguir el mismo caso de negocio que en la guía de puesta en marcha del proyecto: TechStore, una tienda online de electrónica con carrito de compras.

Es viernes a las 17hs. Un cliente reporta lo siguiente:

"Aplico el cupón DESC10 en el checkout, la web me dice que el cupón es válido, pero el total a pagar no cambia — termino pagando el precio completo."

El equipo confirma el bug: la regla de negocio dice "al aplicar un cupón válido, el total debe recalcularse con el descuento aplicado", y hoy eso no está pasando. Es un bug crítico porque afecta directamente los cobros. Un developer ya identificó el problema y subió el arreglo a la rama hotfix/checkout-discount, desplegado en staging. El equipo necesita confirmar en minutos si es seguro liberarlo antes de que arranque el pico de tráfico del viernes a la noche.

Ese es exactamente el escenario para el que se usa este playbook.

3.1 Antes de arrancar: lo que necesitás tener a mano

No hace falta saber programar, pero sí tener a mano estos datos:

Dato Ejemplo con TechStore
Identificador del hotfix o ticket HOTFIX-17
Módulo o historia afectada (con el ID de la historia, si la hay) Checkout / aplicación de cupones de descuento — historia TS-US-14
Qué fue corregido, en palabras simples "El total del checkout no se recalculaba al aplicar un cupón de descuento válido"
Qué regla de negocio cubre el arreglo (el criterio de aceptación, con su ID si lo tiene) "Al aplicar un cupón válido, el total debe recalcularse con el descuento aplicado"
En qué ambiente está desplegado el arreglo https://techstore-staging.com, rama hotfix/checkout-discount
Confirmar que existe un conjunto mínimo de pruebas críticas para el módulo de checkout Una carpeta smoke/ dentro de las pruebas del checkout, con al menos una prueba. Si TechStore nunca armó pruebas críticas para el checkout, hay que crear al menos una antes de seguir
El plan de pruebas de la historia test-plans/TS-US-14-test-plan.md — de ahí sale el caso que se usa para la prueba de regresión del Paso 2

Si no tenés certeza sobre si existen o no pruebas críticas para ese módulo, revisalo en el pre-chequeo de abajo (o pedile al equipo técnico que te confirme si existe la carpeta smoke/ del módulo).

Playbook original

El playbook general se encuentra en el repositorio NEO-releases.

3.2 Cómo arrancar

Antes del Paso 1, contale al asistente el hotfix en cuestión, con la mayor cantidad de detalle posible:

💬 Prompt para el asistente
Quiero validar el siguiente hotfix antes del release:
- ID del hotfix: HOTFIX-17
- Historia o módulo afectado: TS-US-14 / checkout - cupones de descuento
- Qué fue corregido: el total no se recalculaba al aplicar un cupón válido
- Regla que cubre: "al aplicar un cupón válido, el total debe recalcularse
  con el descuento aplicado"
- La app está en https://techstore-staging.com, rama hotfix/checkout-discount

No ejecutes ningún comando todavía, solo guardá esta información como contexto.

La última línea es útil

Sirve para pedirle al asistente que espere tu confirmación antes de empezar a ejecutar pruebas — así podés revisar los datos antes de arrancar.


3.3 Paso a paso

Pre-chequeo — ¿Existe una red de seguridad mínima?

Skill que se usa: ninguna — es una verificación que hacés antes de arrancar.

Qué pasa: antes de tocar nada, se confirma si el módulo afectado ya tiene un conjunto mínimo de pruebas críticas guardado (la "smoke"): una carpeta smoke/ dentro de las pruebas del módulo, con al menos una prueba adentro. Es como preguntar "¿esta ruta ya tiene barandas de seguridad?" antes de circular rápido por ella.

La herramienta del Paso 1 no hace este chequeo por vos

Si no hay pruebas en esa carpeta, la herramienta que ejecuta las pruebas no frena sola: por eso este chequeo se hace antes, a mano (o pidiéndole al equipo técnico que lo confirme). Lo que cuenta es la carpeta smoke/: marcar pruebas como "smoke" de otra forma (por ejemplo, con una etiqueta adentro del archivo) no alcanza para que se tomen en cuenta.

Resultado Qué significa Qué se hace
✅ Sí existen pruebas críticas para el módulo Hay una red de seguridad mínima Se avanza al Paso 1
❌ No existen pruebas críticas para el módulo No hay forma de garantizar que el hotfix sea seguro El playbook se detiene acá mismo — hay que crear al menos una prueba crítica en la carpeta smoke/ de ese módulo antes de continuar

Por qué este chequeo no es opcional

Es la razón por la que este playbook puede ser tan rápido en los pasos siguientes: confía en que ya existe una base mínima de pruebas confiables.


Paso 1 de 3 — Semáforo rápido: ejecutar las pruebas críticas

Skill que se usa: lippia-neo-run-and-heal

Qué pasa: el asistente ejecuta únicamente las pruebas críticas ya existentes del módulo afectado (las de la carpeta smoke/) — no toda la aplicación, solo lo esencial. Actúa como un semáforo: no intenta "arreglar" nada si algo falla, solo informa el resultado tal cual es.

💬 Prompt para el asistente
/lippia-neo-run-and-heal
Ejecutá la smoke prioritaria del módulo checkout (su carpeta smoke/) con:
- max_iterations: 1
- plateau_detection: false
- run_label: "smoke-hotfix"

Con TechStore, esto significa ejecutar las pruebas críticas del módulo de checkout (por ejemplo: "el cliente puede completar una compra", "el total se calcula correctamente", "los cupones válidos se aplican") y ver si todas siguen funcionando con el arreglo ya aplicado.

Dos detalles de este paso

  • Aunque no se repara nada si una prueba falla, el asistente igual hace dos chequeos automáticos antes de ejecutar: completa datos pendientes (valores marcados como TODO) y reemplaza credenciales escritas a mano por las del archivo de configuración. Si toca algo de eso, queda anotado en el resultado.
  • Ejecutar solo la carpeta smoke/ funciona con Playwright. Si el proyecto usa Lippia, no se puede acotar por carpeta y se ejecuta la batería completa.

Checkpoint 1 — Semáforo de release

Resultado Semáforo Qué se hace
✅ Todas las pruebas críticas pasan 🟢 Verde Se avanza al Paso 2
❌ Alguna prueba crítica falla 🔴 Rojo Freno total. Se saltea el Paso 2 y se va directo a armar el reporte (Paso 3) documentando el bloqueo y lo que hay que escalar, y el hotfix no se libera hasta resolverlo

Este es el corazón del playbook

Si el semáforo da rojo, no hay vuelta atrás automática — hace falta que el developer revise qué otra cosa se rompió con el hotfix antes de volver a intentar.


Paso 2 de 3 — Dejar una prueba que vigile este arreglo para siempre

Skill que se usa: lippia-neo-generate-test-suite

Solo se ejecuta si el Paso 1 dio 🟢 verde

Qué pasa: el asistente escribe una prueba automática puntual, dedicada específicamente a este arreglo, que confirma que el comportamiento correcto (el cupón se aplica y el total se recalcula) sigue funcionando. Para eso toma, del plan de pruebas de la historia, solo el caso de la regla corregida — y sin plan de pruebas no puede generarla. A diferencia del playbook Bug Fix Cycle, acá esta prueba nace directamente en verde — no hace falta verla fallar primero, porque el arreglo ya estaba aplicado desde el principio.

💬 Prompt para el asistente
/lippia-neo-generate-test-suite
Modo regresión hotfix: generá SOLO el test para el AC corregido "al aplicar un
cupón válido, el total debe recalcularse con el descuento aplicado"

Es como instalar una cámara de seguridad apuntando exactamente al lugar donde antes había un problema: de ahora en más, si ese problema puntual volviera a aparecer, algo lo va a detectar solo.

Si hay evidencia de una exploración previa del checkout, el asistente usa esos datos técnicos reales de la pantalla. Si no la hay, la prueba queda con algunos datos marcados como pendientes (TODO) — en este playbook es aceptable, y se completan después.

Un retoque antes de guardar la prueba

La herramienta le pone a la prueba un comentario de encabezado pensado para el ciclo de bugs ("esta prueba debe FALLAR hasta que se corrija el bug"). Como en un hotfix el arreglo ya está aplicado, ese comentario hay que cambiarlo a mano por algo como Regression test — HOTFIX-17: recálculo del total con cupón antes de guardarla. El ID del hotfix (HOTFIX-17) va en ese comentario, en el mensaje del commit y en el reporte: la herramienta no lo recibe como dato.

Qué te queda al final de este paso: un archivo de prueba automática nuevo, guardado en el historial del proyecto (un "commit" en Git, obligatorio antes de avanzar), dedicado a este hotfix. Queda en la carpeta de pruebas de la historia, con un nombre del estilo tc-<número>-<descripción-corta>.

Si la urgencia es tan extrema que no hay ni minutos para este paso

Se puede saltar — pero queda registrado en el reporte final como una tarea pendiente, y se crea un ticket de seguimiento, para no perder el rastro de que falta cubrirlo.


Paso 3 de 3 — Reporte final del hotfix

Skill que se usa: lippia-neo-write-test-report

Qué pasa: el asistente arma el reporte con el resultado del semáforo, si se generó o no la prueba de vigilancia (o si quedó pendiente), y la fecha y hora exacta de la validación.

El reporte tiene siempre la misma estructura que cualquier otro reporte de pruebas (no existe una versión "corta"): las secciones que no aplican a un hotfix, como las pruebas manuales, aparecen marcadas como "sin hallazgos". Lo propio del hotfix lo encontrás en tres lugares:

Sección del reporte Qué vas a ver
Resumen ejecutivo Semáforo de la smoke (✅ / ❌), si la prueba de regresión se guardó o quedó pendiente, y el estado general
Resultados automatizados El detalle de qué pruebas críticas pasaron y cuáles fallaron; si el semáforo dio rojo, qué hay que escalar
Resumen y recomendaciones La recomendación de liberar o no liberar, y la tarea pendiente si la prueba de regresión se postergó

Qué te queda al final de este paso: un documento que responde una sola pregunta clave: ¿este hotfix quedó validado y es seguro liberarlo, o no? Queda en la carpeta de reportes del proyecto (por defecto test-results/reports/), con un nombre del estilo TS-US-14-bug-HOTFIX-17-test-report-<fecha-y-hora>.md.

Si el semáforo dio rojo, el reporte también deja documentado por qué se frenó, y distingue dos casos: ❌ falló (la aplicación realmente tiene un problema) o ⚠️ bloqueado (la causa fue el ambiente, por ejemplo que no respondía).


3.4 ¿Qué me queda al finalizar todos los pasos?

Qué obtenés Para qué te sirve
Un veredicto claro de semáforo (verde o rojo) Saber, en minutos, si el hotfix es seguro para liberar
Una prueba automática que vigila el arreglo puntual (si hubo tiempo) Protege ese arreglo específico de romperse en el futuro sin que nadie se dé cuenta
Un reporte con fecha y hora Evidencia de que el hotfix no se liberó "a ciegas" — queda registro de la validación
Si el semáforo dio rojo: el motivo documentado El equipo sabe exactamente qué revisar antes de volver a intentar el release

A partir de acá, el equipo de TechStore puede decidir con información real si sube el arreglo del cupón de descuento antes del pico de tráfico del viernes — y si en algún momento se necesita cobertura más completa sobre ese módulo, se puede complementar después con otro playbook, sin que eso frene la urgencia de hoy.


4. Problemas comunes (y qué hacer)

Lo que ves Por qué puede pasar Qué hacer
El pre-chequeo muestra que no hay pruebas críticas El módulo afectado nunca tuvo una suite mínima ("smoke") armada en su carpeta smoke/ Crear al menos una prueba crítica para ese módulo antes de volver a intentar este playbook
El semáforo del Paso 1 da rojo después de aplicar el hotfix El arreglo urgente rompió otra funcionalidad importante del mismo módulo No liberar; coordinar con el developer para revisar qué otro comportamiento se vio afectado
La prueba del Paso 2 pasa, pero el asistente tuvo que "ayudarla" a pasar Puede haber selectores o datos frágiles en la prueba generada Revisar el resultado; si el arreglo es de fondo, no debería depender de ajustes automáticos
El Paso 2 no genera la prueba No existe el plan de pruebas de la historia Armar el plan de la historia, o postergar la prueba y dejarla registrada como pendiente en el reporte
La prueba del Paso 2 queda con datos marcados como TODO El hotfix llegó sin una exploración previa de la pantalla Es aceptable en este playbook; se completa en el ticket de seguimiento
No hay tiempo ni para el Paso 2 Urgencia extrema Se puede diferir — queda registrado como pendiente en el reporte final, no se pierde de vista
Las pruebas fallan en el login Las credenciales de prueba del proyecto (archivo .env.tests) están vacías o incompletas Avisarle a alguien del equipo técnico para que complete los valores reales — nunca se escriben a mano dentro de las pruebas — y volver a ejecutar el Paso 1
El proyecto no tiene qa-stack.yaml Nunca se ejecutó el bootstrap inicial Ejecutar primero el playbook de puesta en marcha del proyecto

5. Resumen visual del flujo

flowchart TD
    A([🚑 Hotfix ya aplicado<br/>ej: TechStore, arreglo del cupón<br/>de descuento en checkout]) --> B{¿Existe la smoke<br/>del módulo?}
    B -->|No| C([⛔ STOP: crear pruebas<br/>críticas antes de continuar])
    B -->|Sí| D["<b>Paso 1</b> — Semáforo: ejecutar<br/>las pruebas críticas"]
    D --> E{¿Semáforo?}
    E -->|🔴 Rojo| G["<b>Paso 3</b> — Reporte de freno<br/>con lo que hay que escalar"]
    E -->|🟢 Verde| F["<b>Paso 2</b> — Dejar una prueba<br/>que vigile este arreglo"]
    F --> H["<b>Paso 3</b> — Reporte final<br/>del hotfix"]
    G --> I([❌ No se libera])
    H --> J([✅ Aprobado para liberar])