Incidentes de producción con Claude Code: detección, rollback, RCA y prevención

Claude Code acelera el trabajo porque puede leer archivos, editar código y ejecutar comandos. En producción, esa velocidad también aumenta el daño posible: una aprobación vaga puede filtrar un secreto, borrar archivos locales, sobrescribir main, ejecutar una migración peligrosa o disparar llamadas a una API.

Este artículo no afirma que estos casos pertenezcan a una empresa concreta. Son escenarios compuestos a partir de simulacros de ClaudeCodeLab, revisión de repositorios y tareas de contenido. Las horas y cantidades son ejemplos, pero los patrones son útiles para practicar antes de una crisis real.

Un incidente es cualquier evento que afecta usuarios, datos, seguridad, coste o disponibilidad. Contener significa impedir que el daño siga creciendo. RCA es análisis de causa raíz. Rollback es volver a la última versión segura.

Consulta la documentación oficial de Claude Code settings y hooks para la sintaxis actual. Aquí convertimos esas piezas en un flujo: detectar, contener, diagnosticar, revertir, comunicar, hacer postmortem y prevenir recurrencias.

Flujo de respuesta

Fase	Objetivo	Qué pedir a Claude Code
Detectar	Saber qué cambió y a quién afecta	Resumir alertas, logs, diff, despliegues y comandos recientes
Contener	Frenar el daño	Proponer revocar claves, pausar jobs, apagar flags o desactivar endpoints
Diagnosticar	Acotar la causa directa	Comparar el último despliegue sano con el cambio fallido
Rollback	Volver a un estado seguro	Listar versión objetivo, riesgo de datos y comandos de verificación
Comunicar	Alinear a las personas	Redactar estado, impacto, próxima actualización y responsable
Postmortem	Convertir el fallo en aprendizaje	Completar RCA, línea temporal, detección fallida y acciones
Prevenir	Hacer más difícil repetirlo	Añadir permisos, hooks, CI, alertas y revisión

La regla es contener antes de investigar cuando hay secretos, facturación, datos personales o escrituras en BD.

Siete patrones concretos

Patrón	Qué ocurre	Primer paso	Error frecuente
Fuga de secreto	.env, logs o capturas exponen una clave	Revocar, rotar, revisar logs	Limpiar git pero olvidar logs de CI
Borrado peligroso	rm -rf elimina archivos necesarios	Parar, revisar copias, listar no versionados	git checkout . no recupera archivos sin seguimiento
Force push	main sobrescribe commits del equipo	Parar push, mirar reflog, crear rama de recuperación	Confundir --force-with-lease con --force
Migración de BD	Drop, update masivo o lock rompe producción	Pausar escrituras, tomar snapshot, restaurar	Ejecutar SQL no probado en producción
Reintentos infinitos	La lógica de retry sube costes	Matar proceso, pausar cola, revisar límites	”Reintentar” se vuelve bucle infinito
Dependencias rotas	El despliegue arranca con 503	Reactivar despliegue anterior, mirar lockfile	npm update sube versiones mayores
Falta de auth	Endpoint admin queda público	Desactivar endpoint, revisar accesos	”Es admin” no equivale a requisito de autenticación

Casos de uso de incidente

Primero, fuga de API key. La detección puede venir de secret scanning de GitHub, una alerta de nube o la pantalla de facturación. La primera acción es revocar la clave, no investigar. Después se revisan repositorios públicos, PR, logs de CI, chat y monitorización.

git status --short
git diff --cached --name-only
git log --all -- .env .env.local
git grep -n "sk-" -- ':!node_modules' ':!dist'

Segundo, migración fallida de base de datos. Antes de explicar la causa, se paran escrituras con mantenimiento, flag desactivado o workers pausados.

psql "$DATABASE_URL" -c "select now();"
psql "$DATABASE_URL" -c "\d users"
pg_dump "$DATABASE_URL" --schema-only > schema_before_repair.sql

Tercero, reintentos infinitos. Guarda este archivo como incident-budget-runner.mjs y úsalo para envolver tareas batch.

#!/usr/bin/env node
import { spawn } from "node:child_process";

const command = process.argv.slice(2);
const maxAttempts = Number(process.env.MAX_ATTEMPTS || 3);
const maxCostCents = Number(process.env.MAX_COST_CENTS || 200);
const costPerAttempt = Number(process.env.COST_PER_ATTEMPT_CENTS || 0);

if (command.length === 0) {
  console.error("uso: node incident-budget-runner.mjs <comando> [...args]");
  process.exit(2);
}

let estimatedCost = 0;

for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
  const child = spawn(command[0], command.slice(1), {
    stdio: "inherit",
    shell: process.platform === "win32"
  });
  const exitCode = await new Promise((resolve) => {
    child.on("exit", (code) => resolve(code ?? 1));
  });
  estimatedCost += costPerAttempt;
  if (exitCode === 0) process.exit(0);
  if (estimatedCost >= maxCostCents) {
    console.error(`detenido: coste estimado ${estimatedCost} céntimos`);
    process.exit(1);
  }
  const delayMs = Math.min(1000 * 2 ** (attempt - 1), 10_000);
  await new Promise((resolve) => setTimeout(resolve, delayMs));
}

console.error(`falló tras ${maxAttempts} intentos`);
process.exit(1);

Guardrails para Claude Code

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(git push --force *main*)",
      "Bash(git push -f *main*)",
      "Bash(rm -rf /*)",
      "Bash(rm -rf ~*)"
    ],
    "ask": [
      "Bash(git push*)",
      "Bash(rm*)",
      "Bash(npm install*)",
      "Bash(*migrate*)",
      "Bash(*deploy*)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/protect-danger.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail

payload="$(cat)"
command="$(node -e 'const fs = require("fs"); const raw = fs.readFileSync(0, "utf8") || "{}"; const json = JSON.parse(raw); console.log(json.tool_input?.command || "");' <<< "$payload")"
blocked='(rm[[:space:]]+-rf[[:space:]]+(/|~)|git[[:space:]]+push[[:space:]].*(-f|--force)([[:space:]]|$)|DROP[[:space:]]+TABLE|TRUNCATE[[:space:]])'

if [[ "$command" =~ $blocked ]]; then
  echo "Comando peligroso bloqueado: $command" >&2
  exit 2
fi

exit 0

Plantillas de comunicación y postmortem

## Actualización de incidente
- Estado: investigando / contenido / validando recuperación
- Impacto: función, usuarios, hora de inicio
- Acción actual: job detenido, despliegue revertido, logs en revisión
- Próxima actualización: YYYY-MM-DD HH:mm
- Responsable:

# Postmortem: [título]

## Resumen
- Inicio:
- Detección:
- Resolución:
- Impacto:
- Severidad: P0/P1/P2/P3

## Línea temporal
| Hora | Evento |
| --- | --- |
| HH:mm | |

## Causa
- Causa directa:
- Causa raíz:
- Por qué se detectó tarde:

## Prevención
| Acción | Responsable | Fecha límite |
| --- | --- | --- |
| | | |

La referencia externa más útil es Postmortem Culture de Google SRE.

Lecturas y CTA

Lee también buenas prácticas de seguridad, guía de permisos, costes de API y flujo de verificación.

Para empezar solo, usa la cheatsheet gratuita. Para plantillas reutilizables revisa productos de ClaudeCodeLab. Si tu equipo necesita CLAUDE.md, permisos, hooks, revisión y simulacros, entra en formación y consultoría.

Al probar estas plantillas en simulacros de ClaudeCodeLab, el mayor cambio fue escribir la contención antes del diagnóstico. Validar JSON, Bash y Node antes de publicar también redujo errores. Un ensayo de 20 minutos revela alertas ausentes, copias no probadas y permisos demasiado amplios.