Decirle a la IA “encárgate de todo” es pedir un accidente. Cómo montarle un andamio

“Oye, organiza este repositorio, déjalo bonito.”

A la mañana siguiente de pedir eso, la IA había dejado “bonitos” cuarenta archivos. Código que funcionaba, sí, lo había. Pero también había “organizado” —limpiamente, sin dejar rastro— archivos de configuración que jamás debían tocarse.

¿No te ha pasado nunca ese vuelco en el estómago?

¿Por qué una IA que se supone lista provoca accidentes sin inmutarse? La razón es simple: ser lista y saber trabajar con seguridad son dos cosas completamente distintas. Es como ese chaval que saca diez en el examen y, en su primer día de trabajo, rompe la caja registradora. No es un problema de capacidad. Es un problema de andamio.

A ese andamio últimamente lo llaman harness. Hoy te lo explico sin enterrarte en jerga técnica.

A ver, ¿qué es un harness exactamente?

Un harness es un pequeño programa que pones “por fuera” de la IA.

Lo más fácil es imaginarse el arnés de seguridad de un obrero en una obra, o los ruedines de la bici de un niño. Es un mecanismo que deja intactas las capacidades de la persona, pero le impide caerse. En el caso de la IA, cumple papeles como estos:

• Decidir qué se le deja leer (no enseñarle todo).
• Decidir qué se le deja crear (dejar claro el objetivo).
• Decidir hasta dónde actúa sola y dónde tiene que preguntarle a un humano.
• Comprobar de forma mecánica si lo que produjo está roto o no.

“Escribir un buen prompt” es solo una pequeña parte de todo esto. Si te pasas el día puliendo prompts y aun así los accidentes no bajan, es porque estás practicando malabares en un monociclo sin haberte puesto los ruedines primero.

¿Por qué se habla tanto de esto justo ahora?

Hasta hace poco, lo que le pedías a una IA era más o menos “escríbeme un texto” o “escríbeme este código”. Lo que salía, lo leía un humano y decidía. Y listo.

Pero ahora le estamos empezando a delegar el trabajo en sí. Que lea archivos, que elija un ángulo que no choque con artículos ya publicados, que revise los cambios, que dé de alta algo en un servicio externo, que reporte la causa si algo falla. Cuando llegas hasta ahí, ya no hay un humano metido en cada paso. Y por eso el riesgo de que “haga cosas por su cuenta y la líe” se disparó de golpe.

Si Claude Code tiene buena fama, no es tanto porque el modelo sea listo, sino porque ese andamio está bien hecho. La herramienta para leer archivos, la de buscar, el mecanismo que frena operaciones peligrosas, el que le hace recordar las reglas del proyecto. Toda esa “periferia aburrida” está sólida. Lo que está de moda no son los prompts mágicos, es esa periferia aburrida.

Primero, hagámoslo funcionar: un harness mínimo de 30 líneas

Explicar cansa; mejor ponerlo a funcionar. Vamos a montar el andamio más pequeño posible: uno que solo le permite a la IA “leer y escribir” y que jamás la deja tocar nada fuera de una carpeta que decidimos nosotros. Con Node.js y una clave de API de Anthropic, arranca.

Primero, la preparación.

mkdir harness-demo && cd harness-demo
npm init -y
npm install @anthropic-ai/sdk
mkdir sandbox
echo "# nota" > sandbox/note.md

Después escribimos la “lista de permisos”. Este es el corazón del harness. Es la declaración de “no la dejes tocar nada fuera de sandbox”.

{
  "workspace": "./sandbox",
  "maxSteps": 6
}

Y ahora el cuerpo (harness.mjs). Quédate con un solo punto. safePath es el guardián que “para en seco si intenta salir de la carpeta”. Con solo tener esto, el “accidente de los cuarenta archivos” del principio no ocurre.

import Anthropic from "@anthropic-ai/sdk";
import { readFile, writeFile } from "node:fs/promises";
import path from "node:path";

const client = new Anthropic();
const policy = JSON.parse(await readFile(new URL("./policy.json", import.meta.url), "utf8"));
const root = path.resolve(policy.workspace);

// El guardián: si intenta salir de la carpeta de trabajo, lo para ahí mismo
function safePath(p) {
  const resolved = path.resolve(root, p);
  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
    throw new Error(`${p} está fuera de la carpeta de trabajo. Solo puedo tocar lo que hay dentro de sandbox.`);
  }
  return resolved;
}

const tools = [
  { name: "read_file", description: "leer un texto dentro de sandbox",
    input_schema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
  { name: "write_file", description: "escribir un texto dentro de sandbox",
    input_schema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
];

async function useTool(name, input) {
  if (name === "read_file") return await readFile(safePath(input.path), "utf8");
  if (name === "write_file") { await writeFile(safePath(input.path), input.content, "utf8"); return "Escritura OK"; }
  throw new Error(`Herramienta desconocida: ${name}`);
}

const messages = [{ role: "user", content: process.argv.slice(2).join(" ") || "Lee note.md y escribe un resumen en summary.md." }];

for (let step = 0; step < policy.maxSteps; step++) {
  const res = await client.messages.create({
    model: process.env.ANTHROPIC_MODEL || "claude-sonnet-4-6",
    max_tokens: 1024,
    tools,
    system: "Eres un encargado de archivos prudente. Usas las herramientas solo cuando hace falta y trabajas únicamente dentro de sandbox.",
    messages,
  });
  messages.push({ role: "assistant", content: res.content });

  const calls = res.content.filter((b) => b.type === "tool_use");
  if (calls.length === 0) { console.log(res.content.find((b) => b.type === "text")?.text ?? ""); break; }

  const results = [];
  for (const c of calls) {
    try { results.push({ type: "tool_result", tool_use_id: c.id, content: String(await useTool(c.name, c.input)).slice(0, 4000) }); }
    catch (e) { results.push({ type: "tool_result", tool_use_id: c.id, is_error: true, content: e.message }); }
  }
  messages.push({ role: "user", content: results });
}

Y para ejecutarlo, solo esto.

node harness.mjs

Son apenas unas decenas de líneas, pero ya tienes separados “la IA en sí”, “las herramientas que puede usar”, “el alcance de los permisos”, “el tope de reintentos” y “el mecanismo que la frena si algo se rompe”. Ese es el esqueleto de un harness. A partir de aquí le vas sumando búsqueda, ejecución de tests, esperar aprobación y notificaciones, y va creciendo hasta parecerse a Claude Code.

Dónde se nota de verdad (tres casos)

1. Control de calidad cuando produces artículos o documentos en serie Si te quedas en “escribe un blog”, la IA te suelta tan tranquila artículos flojos o “casi el mismo tema” una y otra vez. Ahí le metes al harness un guion: “lee los títulos que ya existen → elige un ángulo que no choque → escribe el cuerpo → comprueba mecánicamente el número de caracteres y los enlaces”. Entonces, antes de que un humano se ponga a sufrir decidiendo si está bien o mal, el guardián descarta el artículo flojo. A mí, así, me empezaron a saltar varios borradores al mes que se frenan antes de publicarse. Y se agradece que se frenen, en serio.

2. Triaje de los mensajes que llegan “Lee los mensajes que entran y avísame solo de los que pintan a oportunidad de venta.” Leer, que lo haga solo, perfecto. Pero dar de alta el contacto en la lista de clientes queda en suspenso hasta que un humano pulsa el botón. Eso se lo obligas con el harness. Leer, automático; escribir, en borrador (dry-run); el alta final, solo humano. Así desaparece el accidente de meter en la base de datos de producción a un cliente que clasificaste mal.

3. Un respiro antes del despliegue Antes de pulsar el botón de publicar, le obligas a comprobar siempre: que la build pasa, que las variables de entorno están todas, que el diff es el que esperabas, que existe un procedimiento para revertir. La IA tiende a mirar solo “la última línea” del log de error y a arreglar algo que no era, así que el truco es decidir de antemano “dónde mirar”. No le pases el log entero; recórtalo a las pocas decenas de líneas que importan. Solo con eso bajan muchísimo los arreglos que apuntan a otro lado.

Tres diseños que puedes “robarle” a Claude Code

Cuando montes tu propio harness, no hace falta pensarlo todo desde cero. Claude Code es una mina de ejemplos. No tienes que copiarlo todo; con incorporar pronto estos tres, gana estabilidad de golpe.

El primero: separa las reglas por capas. Lo que no cambia nunca, al archivo de configuración; las instrucciones de solo esta vez, a una nota del momento; las preferencias que usarás mucho tiempo, a otro sitio. Si lo metes todo en el prompt cada vez, se alarga y baja la precisión.

El segundo: deja el trabajo determinista a los comandos. Formatear, comprobar, testear: es más rápido y más fiable lanzarlo con un comando como npm test que pedírselo a la IA. A la IA le dejas solo el trabajo de “pensar”.

El tercero: manda las búsquedas pesadas a otro encargado. Si vuelcas logs larguísimos o lecturas masivas de archivos en la conversación principal, el juicio importante se vuelve borroso. Que la investigación previa la haga otro proceso y tú recibes solo la conclusión. Solo con eso recuperas el filo de las decisiones.

Tres metidas de pata que cometí yo

Lo escribo sin maquillar. Mis primeros harness fueron un desastre de accidentes.

La primera: le di demasiadas herramientas. Pensando que sería útil, le preparé unas treinta, y la IA se quedaba dudando “¿cuál uso?” y encadenaba elecciones raras. Ahora las dejo en cinco a diez al principio.

La segunda: los mensajes de error eran poco amables. Cuando solo devolvía Error: failed, la IA no podía arreglar nada. Cuando empecé a devolver hasta la causa y el siguiente paso, tipo No encuentro README.md. En sandbox solo está note.md, de repente empezó a resolverlo sola.

La tercera: confié la revisión solo a mis ojos. Eso de “al final ya lo reviso yo” se rompe sin falta el día que vas con prisa. Desde que puse guardianes que una máquina entiende —número de caracteres, enlaces rotos, errores de tipos—, las revisiones de madrugada bajaron muchísimo.

Si vas a empezar, empieza por aquí

No montes de entrada “un agente listísimo y totalmente automático”. Elige una tarea pequeña que, si falla, puedas deshacer. Revisar un borrador, una primera pasada de un PR, el triaje de mensajes, la comprobación antes de publicar en staging. Ese tamaño es el justo.

El orden es siempre el mismo: 1) acota bien estrecho qué le dejas leer → 2) deja clarísimo el objetivo (el entregable) → 3) que las comprobaciones las haga un comando todo lo posible → 4) las operaciones peligrosas (borrar, base de datos de producción, cobros, force push) ponlas al principio todas en “pregúntale al humano”. Solo las que confirmes que son seguras, las asciendes después a automáticas. Con solo respetar este orden, los accidentes bajan una barbaridad.

Cómo decidir los permisos lo tienes en la guía de configuración de permisos de Claude Code, y cómo preparar la base para usarlo en equipo, en buenas prácticas de CLAUDE.md. Si quieres trocear trabajos largos, échale un ojo también a patrones de uso de subagentes. La fuente oficial sobre cómo pensar todo esto es la documentación del Claude Agent SDK.

Lo que pasó cuando lo probé de verdad

Desde el “accidente de los cuarenta archivos” del principio, dejé de torturarme con la pregunta de si me fío o no de la IA. Lo que miro ahora es otra cosa: en qué guardián se frenó. Con solo añadirle un safePath al harness mínimo, los accidentes fuera de la carpeta bajaron a cero. Al sumar la comprobación automática de caracteres y enlaces, los artículos flojos empezaron a frenarse antes de publicarse. Buscar una IA lista cansa; mejor montar primero el andamio en el que, si te caes, no te haces daño. Parece el camino largo, pero mi experiencia hoy es que es el más rápido.

En resumen

El harness engineering no es la técnica de adornar prompts. Es la técnica de diseñar qué le enseñas a la IA, qué le dejas hacer, dónde la frenas y cómo lo compruebas. Empieza por poner a funcionar esas 30 líneas de arriba y por añadirle un solo “guardián” a tu propio trabajo. La calidad del trabajo de una IA la decide, más que la inteligencia del modelo, el andamio que tiene por fuera.

Si quieres incorporar la IA a tu trabajo de forma más sistemática y segura, asómate al listado de materiales y plantillas; y si quieres dejar afinados permisos, revisión y verificación con todo el equipo, mira la formación y asesoría de implantación.