---
title: "Chat de IA para depurar k6: convertir errores en hipótesis más rápido"
description: "Depura fallos de k6 con chat de IA estructurado: pega errores, métricas y snippets—luego prioriza hipótesis antes de cambiar escenarios o infra."
publishDate: "2026-07-21"
draft: false
keyword: "chat ia k6 depuración hipotesis"
intent: "MOFU"
cta: "Usa el flujo de escritorio de Performate: imports, corridas k6 y análisis asistido por IA según tu plan, para publicar más rápido sin saltarte la validación."
tags: ["k6", "pruebas-de-carga", "ia", "performate", "debugging"]
translationOf: ai-chat-k6-debugging-hypotheses
---

La **depuración de k6 con chat de IA** rinde en los primeros diez minutos tras un umbral rojo—cuando hay logs pero no relato. El modelo debe **agrupar pistas** y proponer hipótesis ordenadas, no declarar causa raíz antes de tocar escenarios, pools o auth.

En esta guía verás cómo estructurar prompts ante fallos k6, qué artefactos pegar (salida de umbrales, métricas etiquetadas, límites del snippet) y cómo validar sugerencias de la IA con reruns de una sola variable.

## Por qué el chat sin estructura desperdicia la ventana crítica

Los fallos k6 rara vez son errores de una línea. Son **composiciones**: umbrales en `http_req_failed`, latencia de cola en un tag, `dropped_iterations` por executor mal configurado o tormentas 401 que hacen ver la latencia “sana” en los pocos éxitos.

Sin estructura, el chat replica el pánico:

- Sugiere subir VUs cuando el problema es el token vencido.
- Reescribe scripts enteros cuando solo falta `preAllocatedVUs`.
- Mezcla routing de staging con lenguaje de SLO de producción.

Trata la IA como **ranker de hipótesis**. Tú aportas hechos inmutables—código de salida, líneas de umbral, últimas 20 líneas de log, bloque de escenario—y el modelo devuelve causas ordenadas con la prueba más rápida para refutar cada una. Combínalo con [runbook para depurar prueba de carga fallida](/es/blog/runbook-depurar-prueba-carga-fallida).

### El paquete mínimo de depuración

Antes del chat, arma:

1. **Resumen de umbrales** (expresión fallida y valor observado).
2. **Parámetros de escenario** (executor, rate, duration, `maxVUs`).
3. **Corte etiquetado** si las métricas agregadas mienten—p. ej. `http_req_duration{route:checkout}` vs global.
4. **Un fallo representativo de `check`** o distribución de códigos de estado.
5. **Hechos de entorno** (staging vs prod-like, flags)—no secretos.

Ese paquete separa hipótesis útiles del “revisa la base de datos” genérico ([ejemplos de umbrales k6](/es/blog/ejemplos-umbrales-k6)).

## Implementación práctica en k6: tags de debug y script de repro acotado

Cuando la IA propone un arreglo, demuéstralo con un **repro estrecho**: poco tráfico, mismos tags y umbrales. El script ilustrativo simula auth dominando `http_req_failed` para practicar ranking sin fundir staging.

**Ejemplo de script (ilustrativo—no listo para producción)**

**Qué demuestra este ejemplo:**

- **Cabecera `X-Debug-Run-Id`** para correlacionar k6 con APM al validar hipótesis.
- **Tag `debug_phase`** marca reruns tras cada cambio de una variable.
- **Tasa baja** mantiene el repro barato con umbrales estrictos.
- **Checks separados de umbrales** para que la IA distinga fallo funcional vs SLO.

```javascript
import http from 'k6/http';
import { check, sleep } from 'k6';
import exec from 'k6/execution';

const BASE = __ENV.API_BASE || 'https://staging.example.com';
const DEBUG_ID = __ENV.DEBUG_RUN_ID || `debug-${Date.now()}`;

export const options = {
  scenarios: {
    repro: {
      executor: 'constant-arrival-rate',
      rate: 2,
      timeUnit: '1s',
      duration: '2m',
      preAllocatedVUs: 3,
      maxVUs: 10,
      tags: { debug_phase: __ENV.DEBUG_PHASE || 'baseline' },
    },
  },
  thresholds: {
    http_req_failed: ['rate<0.02'],
    'http_req_duration{route:orders}': ['p(95)<600'],
  },
};

export default function () {
  const res = http.get(`${BASE}/api/orders`, {
    headers: {
      Authorization: `Bearer ${__ENV.TOKEN}`,
      'X-Debug-Run-Id': DEBUG_ID,
    },
    tags: { route: 'orders', debug_phase: __ENV.DEBUG_PHASE || 'baseline' },
  });
  check(res, {
    'orders 2xx': (r) => r.status >= 200 && r.status < 300,
    'not 401': (r) => r.status !== 401,
  });
  if (res.status === 401) {
    console.warn(`401 en vu=${exec.vu.idInTest} iter=${exec.vu.iterationInScenario}`);
  }
  sleep(0.3);
}
```

**Patrones que funcionan**

- **Pegar líneas de umbral literalmente**; pedir tres hipótesis por probabilidad y costo de refutación.
- **Una variable por rerun:** arreglo de token → `DEBUG_PHASE=after_auth_fix`, luego rate, luego pools ([errores comunes en pruebas de carga](/es/blog/errores-comunes-pruebas-de-carga)).
- **Segmentar por tags** antes de aceptar consejos agregados ([k6 observabilidad métricas tags](/es/blog/k6-observabilidad-metricas-tags)).
- **Correlacionar `X-Debug-Run-Id`** con trazas si la IA sospecha saturación aguas abajo ([correlation IDs y trazabilidad distribuida](/es/blog/correlation-ids-trazabilidad-distribuida-k6)).

**Antipatrones a evitar**

- Pedir “arregla el script” sin la expresión de umbral fallida.
- Subir `maxVUs` y duración a la vez—no sabrás qué ayudó.
- Tratar la confianza del modelo como aprobación de release.

**Pro tip (comando de ejemplo):**

```bash
k6 run debug-repro.js -e DEBUG_PHASE=after_auth_fix -e DEBUG_RUN_ID=inc-4421 --summary-trend-stats="p(95),p(99)"
```

**Qué demuestra este comando:** cada rerun es comparable en resúmenes y APM gracias a `DEBUG_RUN_ID` y tags `debug_phase`.

## Marco de decisión: chat primero vs runbook primero

| Situación | Acción recomendada |
|:---|:---|
| Primer umbral rojo de la semana | Paquete runbook + ranking de hipótesis con IA |
| 401/403 intermitentes bajo carga | Hipótesis auth primero; repro a 2 req/s |
| `dropped_iterations` en alza | Hambre de executor/VU antes de tunear backend |
| Latencia de cola solo en una ruta | Corte por tag + trace; ignorar `http_req_duration` global |
| IA sugiere reescribir >30% del script | Rechazar; un módulo ([propiedad scripts k6 generados por IA](/es/blog/propiedad-scripts-k6-generados-ia)) |

**Usa chat con IA primero si** tienes el paquete completo y necesitas ordenar cuatro causas plausibles en menos de quince minutos.

**Usa runbook sin IA si** el fallo es mismatch de entorno conocido (URL base, secreto CI vencido)—[k6 secretos en entornos de prueba](/es/blog/k6-secretos-entornos-prueba).

**Usa análisis integrado si** la app de escritorio ya agrupa fallos—el chat valida el informe ([análisis de pruebas de carga con Gemini](/es/blog/analisis-pruebas-carga-gemini-ia)).

## Observabilidad, documentación y próximos pasos

La depuración por hipótesis solo perdura si el próximo ingeniero puede reproducir el razonamiento:

- [ ] Registrar `DEBUG_RUN_ID` en consola k6 y en búsqueda APM/trace.
- [ ] Archivar JSON de resumen por rerun con `debug_phase` en nombre o tags.
- [ ] Anotar hipótesis refutada y la única variable cambiada.
- [ ] Escalar a infra solo tras descartar auth, rate y cortes por tag.
- [ ] Actualizar el runbook del equipo si un modo se repite dos veces en un trimestre.

## Cómo Performate simplifica la depuración k6 asistida por IA

**Ejemplo: de umbral rojo a hipótesis ordenadas sin caos de scripts**

1. **Correr el escenario fallido en la app de escritorio** y abrir el informe integrado. *Problema resuelto:* umbrales, checks y desglose de estados en una vista.
2. **Copiar el resumen del fallo** al análisis asistido por IA (según plan). *Problema resuelto:* el modelo parte de números que el informe ya calculó.
3. **Crear escenario repro a tasa baja** en el editor—mismos requests, menos req/s, mismos tags. *Problema resuelto:* reruns baratos mientras validas hipótesis.
4. **Aplicar un solo arreglo** (token, `preAllocatedVUs`, cabecera) y fijar `debug_phase` en tags. *Problema resuelto:* la cadena de experimentos es visible en exports y comparaciones.
5. **Comparar corridas lado a lado** filtrando por `debug_phase`. *Problema resuelto:* ves si movió `http_req_failed` o la cola—sin adivinar.
6. **Exportar el k6 validado** para CI en verde ([pruebas de carga en CI/CD](/es/blog/pruebas-de-carga-en-ci-cd)). *Problema resuelto:* el arreglo sobrevive al sprint; el chat no.

## Cierre

El chat de IA para depurar k6 es un **acelerador de hipótesis**, no piloto automático. Trae hechos de umbrales, tags y escenarios; sal con pruebas ordenadas; cambia una variable por rerun.

La próxima vez que un umbral se ponga rojo, pega la línea del fallo antes que el script entero—las hipótesis ordenadas estarán más claras en cinco minutos.

[Prueba Performate gratis](https://performate.app) | [Reserva una demo](/demo) | [Checks k6](https://k6.io/docs/using-k6/checks/)