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.yamldel 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:
- 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).
- 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.
- 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.
- 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 labelhotfix. 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:
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.
/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.
/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])