Esos 15 minutos de trabajo manual cada mañana: se los endosé enteros a la IA

Cada mañana, antes de prepararme el café, hacía el mismo trabajo.

Abrir la carpeta, revisar los logs de ayer, mirar a ojo que los tests no se hubieran caído, pegar en el bloc de notas el diff que me llamaba la atención. Cada cosa, un minuto. Pero todo junto, para cuando terminaba, el café ya estaba frío. Cada día. De lunes a viernes, sin falta.

Una mañana, de repente, lo pensé: “¿esto lo tengo que hacer yo de verdad?”.

Te lo digo ya: no. Ahora esa rutina la termina un pequeño script mientras yo me lavo la cara. Y encima con más cuidado que yo. Hoy te cuento esa historia, y te enseño el código entero por el camino.

La “automatización” no es solo cosa de programadores

Cuando oyes “automatización” te imaginas algo aparatoso: CI/CD, pipelines de despliegue, esas cosas. Pero lo que yo quiero contarte es mucho más humilde.

Esa copia-pega que haces a mano cada día medio en piloto automático. Pasársela a otro.

Por ejemplo: sacar números de varios archivos y juntarlos en una tabla. Ordenar unas notas con un formato fijo. Poner en paralelo qué cambió entre ayer y hoy. Localizar notas que ya están viejas. Todo eso es más “mover ojos y dedos” que “pensar”. Cuando lo hace un humano, mete la pata, se aburre y, sobre todo, se le va el tiempo como agua.

Aquí es donde entra la IA; en concreto, Claude Code. Y la clave es una sola: no le sueltes todo a la IA de golpe. “Hazlo todo bonito” es pedir un accidente (luego te lo demuestro con mis cagadas). En vez de eso, decides antes qué puede leer, qué tiene que hacer y qué no puede tocar, y solo le delegas la parte repetitiva. Con eso, cambia el mundo.

Por cierto, aquí sale mucho la palabra “harness”. Traducida literalmente es el arnés de un caballo, pero en el fondo es el marco externo que evita que la IA se descontrole. Qué entra, hasta dónde se le permite, cómo se registra y dónde se frena si va mal. Quédate con esto: ese marco lo montas primero.

Hasta dónde delegar y a partir de dónde mirar tú

Antes de delegar, traza la línea una sola vez. Si te saltas esto, parecerá que vas más rápido, pero después te llevas un susto. Lo que yo recomiendo son cuatro niveles.

Nivel	Lo que delegas a la IA	Lo que miras tú
Investigar	Resumir logs, diffs, el contenido de archivos	La importancia y en qué orden atacar
Ordenar	Unificar formato, juntar en tabla, hacer borradores	El criterio del contenido y el OK final
Revisar	Señalar tests caídos, notas viejas, diffs raros	Cuáles de esos avisos aceptas
Ejecutar	Generar y copiar cosas de toda la vida	El botón de borrar, enviar, publicar

Trazar la línea es simple. Lo que tiene marcha atrás, delégalo. Lo que no tiene marcha atrás, púlsalo tú con tu propio dedo. Borrar, enviar, cobrar, publicar. Estos cuatro, al principio, déjalos todos en “antes pregúntale al humano”. Solo lo que confirmes que es seguro, lo asciendes después a automático. Si lo haces al revés, lloras.

Esta forma de trazar la línea la desarrollo más a fondo en cómo montar aprobaciones y sandbox; si lo lees junto a esto, creo que te encaja del todo.

Primero hazlo funcionar: que te haga la revisión de cada mañana

Dejémonos de discursos y pongamos algo real a funcionar. Voy a convertir en script tal cual eso que yo hacía cada mañana: “mirar logs y tests y anotar lo que hay que vigilar hoy”. Con Node.js y una clave de API de Anthropic, arranca.

Guárdalo como scripts/morning-check.mjs. He dejado todos los comentarios en español.

#!/usr/bin/env node
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";

const logDir = ".claude-logs";
const lockFile = join(logDir, "morning.lock"); // la llave que evita arrancar dos veces
const stamp = new Date().toISOString().replace(/[:.]/g, "-");
const logFile = join(logDir, `morning-${stamp}.log`);

function fail(message) {
  console.error(message);
  process.exit(1);
}

// Ayudante pequeño que ejecuta un comando y recoge la salida tal cual
function run(command, args, options = {}) {
  const result = spawnSync(command, args, {
    encoding: "utf8",
    shell: process.platform === "win32", // truco para que también funcione en Windows
    ...options,
  });
  const output = `${result.stdout || ""}${result.stderr || ""}`;
  if (result.status !== 0) {
    writeFileSync(logFile, output);
    fail(`Comando fallido: ${command} ${args.join(" ")} / detalles en ${logFile}`);
  }
  return output;
}

// Si se te olvida la llave, no hace nada y se para (esto es importante)
if (!process.env.ANTHROPIC_API_KEY) {
  fail("Configura primero ANTHROPIC_API_KEY.");
}

mkdirSync(logDir, { recursive: true });
if (existsSync(lockFile)) {
  fail(`La revisión anterior todavía está corriendo: ${lockFile}`);
}
writeFileSync(lockFile, String(process.pid));

try {
  // 1. Reunir el estado actual (esto no es la IA, son solo comandos)
  const status = run("git", ["status", "--short"]);
  const tests = run("npm", ["test"]);

  // 2. Pasarle el material a la IA para que liste solo lo que hay que vigilar hoy
  const prompt = [
    "Eres mi encargado de la revisión matinal.",
    "Lee este git status y el resultado de los tests, y enumera en viñetas lo que hay que vigilar hoy.",
    "No modifiques, borres, hagas commit ni envíes nada de código. Solo leer.",
    "Clasifica en: autenticación / doble ejecución / cómo revertir / logs / requiere decisión humana.",
    "",
    "git status:",
    status || "(sin cambios)",
    "",
    "salida de los tests (solo el final):",
    tests.slice(-12000), // no le pases el log entero, con el final basta
  ].join("\n");

  const report = run("claude", [
    "-p", prompt,
    "--max-turns", "5",
    "--permission-mode", "plan", // modo solo lectura, no le dejes reescribir
    "--output-format", "text",
  ]);

  writeFileSync(logFile, report);
  console.log(`Notas de la revisión de hoy guardadas → ${logFile}`);
} finally {
  rmSync(lockFile, { force: true }); // al terminar, quita siempre la llave
}

Y para ejecutarlo, solo esto.

node scripts/morning-check.mjs

Son unas decenas de líneas, pero ahí dentro ya está todo: “reunir el material”, “pasárselo a la IA”, “limitarlo a solo lectura”, “evitar el doble arranque con la llave” y “guardar el log”. Ese es el esqueleto de la automatización. Si tu rutina matinal es otra, basta con cambiar las partes de git status o npm test por los comandos que tú tecleas a diario. Lo escribí para que funcione aunque lo copies sin entender el interior, pero cuando vayas cogiendo confianza, métele mano.

Dónde se nota de verdad (tres casos)

1. Juntar archivos dispersos en una sola hoja Tienes 7 CSV de facturas tirados por una carpeta. Cada mes los abría a mano y sacaba el total. Pegar uno a uno en Excel, sumar, repasar. Unos 20 minutos. Y encima el mes pasado, por un fallo al copiar, reporté un número con un dígito desplazado y luego me puse rojo. Ahora con “lee todos los CSV de esta carpeta y hazme una tabla con el total y solo las filas que se desvíen mucho de la media”, listo. Un humano tecleando un total desplaza un dígito; una máquina no. Hasta el repaso desapareció.

2. Poner en paralelo el ayer y el hoy Cuando quieres saber solo “qué cambió” entre un archivo de configuración o una nota y su copia de ayer. Leerlo entero de arriba abajo para comparar es un infierno; los ojos resbalan y no ves dónde difiere. Así que dejo que la IA recoja solo el diff, y soy yo quien juzga “si es un cambio con sentido o solo una errata”. No le delego el juicio a la IA, solo el trabajo de encontrar el cambio. De 3 minutos a ojo a 5 segundos.

3. Ordenar notas caóticas en un formato fijo Esas notas garabateadas en mitad de una reunión. Fechas desordenadas, sin títulos, llenas de erratas, flechas sueltas que no se entienden. A eso le pido “dale el formato de esta plantilla, pero no añadas absolutamente nada al contenido”. Aquí lo importante es no hacer que escriba de cero, sino que solo dé forma. Si dices “resúmelo bonito”, la IA se inventa cosas que tú nunca dijiste. Le clavas “solo la forma”. Solo con eso, deja de añadirte mentiras.

Tres metidas de pata que cometí yo

Sin postureo: mis primeras automatizaciones fueron una cadena de accidentes.

La primera. Solté todo con un “organízalo bonito”. Resultado: la IA me “organizó” hasta archivos de configuración que jamás debían tocarse. El código que funcionaba quedó, vale, pero aquella mañana se me fue de verdad el color de la cara. Se borró el .env, el servicio dejó de arrancar y tardé una hora en recuperarlo. Desde entonces, siempre indico de antemano el alcance: “solo dentro de esta carpeta”, “este archivo no lo toques”. No puedes esperar que la IA lo adivine.

La segunda. Le metí el log entero en el prompt. Con intención de ser amable le pasé decenas de miles de líneas, y la línea del fallo que importaba quedó enterrada, así que la IA me señalaba “el problema está aquí” en un sitio totalmente equivocado. Solo se hincharon la factura y el tiempo, y acabé releyéndolo yo. Ahora, como en el código de arriba, paso solo el final con slice(-12000). El error sale al final. Y la IA también lee mejor las últimas líneas. Por eso con el final basta.

La tercera. Ejecuté el mismo script por duplicado. Configuré mal el programador de tareas y la revisión matinal arrancó dos veces, casi a la vez. Se sobrescribió el log y ya no sabía cuál era el bueno. Lo peor es cuando se trata de un trabajo que “escribe”: generas la misma nota dos veces y luego borras los duplicados a mano. Desde que metí el archivo de bloqueo (la llave), al segundo que llega lo rechaza con un “la anterior todavía está corriendo” y se resuelve a la primera. Son solo tres líneas, pero sin ellas, justo la mañana de prisas te llevas el susto.

Si vas a empezar, empieza por aquí

No apuntes de entrada a la automatización total. Elige una sola tarea pequeña que, aunque falle, no te haga llorar. La revisión matinal, sumar archivos, dar formato a notas. Ese tamaño es el justo.

El procedimiento es siempre el mismo: 1) acota bien estrecho qué le dejas leer → 2) di con claridad el objetivo (el resultado) → 3) que las comprobaciones las haga un comando todo lo posible → 4) borrar, enviar, cobrar y publicar déjalos fijos en “pregúntale al humano”. Solo lo que ya conozcas y sepas seguro, lo asciendes después a automático. Con solo respetar este orden, los accidentes bajan una barbaridad.

Cuando te entren ganas de lanzarlo a una hora fija cada día, lo registras en cron o en el programador de tareas.

# Linux/macOS: ejecutar entre semana a las 8:15 de la mañana
15 8 * * 1-5 cd /path/to/repo && /usr/bin/node scripts/morning-check.mjs >> .claude-logs/cron.log 2>&1

# Windows: registrar en el programador de tareas todos los días a las 8:15
schtasks /Create /TN "MorningCheck" /SC DAILY /ST 08:15 /F /TR "powershell -NoProfile -ExecutionPolicy Bypass -Command \"cd C:\path\to\repo; node scripts\morning-check.mjs\""

Qué mirar cuando se para, o qué significan argumentos finos como --permission-mode, lo tienes de primera mano en la referencia oficial de la CLI. Si te atascas, mira ahí primero y te ahorras rodeos. Y si tropiezas en el primer paso, échale un vistazo también a Claude Code: los primeros 30 minutos.

Lo que pasó cuando lo probé de verdad

Te lo digo de verdad: la primera semana, el script tardaba más que hacerlo a mano. Se paraba porque olvidaba la llave, devolvía respuestas raras por exceso de log, el programador ni siquiera arrancaba. Lo arreglé todo a mano.

Pero a partir de la segunda semana, empezó a funcionar. Ahora, por la mañana, cuando me lavo la cara y vuelvo al escritorio, en .claude-logs me esperan solo 3 a 5 líneas con lo que hay que mirar hoy. Tipo “los tests en verde, pero esta dependencia está vieja” o “en el diff hay un archivo que no recuerdo haber borrado, conviene revisar”.

Lo que más me alegró fue que desapareció la pereza de cada mañana. Se acabó ese rato de hacer lo mismo por inercia, y ese tiempo lo paso ahora a trabajo donde de verdad uso la cabeza. En vez de buscar una IA lista, ir pasándole a la máquina, uno a uno, mis cinco minutos más latosos. Es humilde, pero fue lo que más me sirvió.

En resumen

La automatización no es ese asunto grandilocuente del despliegue. Es hacer que la máquina te releve de esa copia-pega que haces a mano cada día medio en piloto automático. Solo eso.

El truco son tres cosas. Acota bien estrecho qué le dejas leer. Pon el resultado en palabras. Las operaciones sin marcha atrás, púlsalas con tu propio dedo. Empieza por adaptar el script de arriba a tu trabajo y quítate un solo bloque de cinco minutos de mañana.

Si quieres aprenderlo de forma más estructurada, o automatizar de golpe el trabajo de tu equipo, en el listado de materiales tengo cosas para aprender con las manos. Y si quieres consultar tu caso concreto, desde ahí mismo puedes escribirme.