Ingeniería gráfica explicada: qué es, cuándo usarla y cuándo no
La mayoría de la gente utiliza la IA entre un 5 y un 10% de lo que realmente puede hacer. Existe una forma más rápida y es más grande de lo que parece. Aprendalo y podrá optimizar enormes procesos, no solo tareas personales.
Ésta es la habilidad detrás de roles reales en grandes empresas. La diferencia entre hacer un trabajo y diseñar cómo se hacen cientos de ellos.
Tuve suerte temprano. Cuando estudié en una de las mejores universidades de Dinamarca, teníamos un curso completo sobre una cosa: cómo diseñar un proceso en forma de diagrama y hacerlo lo más eficiente posible.
En aquel entonces se sentía abstracto. Ahora es exactamente sobre lo que discuten los mejores ingenieros de IA en su línea de tiempo.
Al final de este artículo, comprenderá la ingeniería gráfica mejor que casi cualquier persona a la que siga: qué es realmente un gráfico, la única prueba que instantáneamente hace que su IA sea más rápida, el patrón único que se amortiza por sí solo, dónde estas cosas se estropean silenciosamente, cuándo un gráfico es la herramienta incorrecta y cómo construir uno real usted mismo en un par de minutos.
Antes de entrar en materia, sígueme en X y únete a mi canal de Telegram que acabo de crear, donde publico más contenido de IA todos los días. Ambos son gratis.
X-https://x.com/AnatoliKopadze
Telegrama: https://t.me/kopadzemp
1 - De dónde vino esto.
Hace un mes todo el campo hablaba de bucles. Luego, Peter Steinberger publicó la línea anterior, y un rincón de Internet que acababa de terminar de aprender los bucles los declaró viejas noticias de la noche a la mañana.
El chiste aterrizó porque era verdad a medias. Si has leído mi artículo sobre Loops, ya tienes la base. Un bucle es un agente que mejora una cosa una y otra vez: prueba, comprueba, ajusta y vuelve a empezar. Esa fue la habilidad del mes pasado.
A lo que todos se trasladaron no es a un circuito mejor. Es un gráfico de bucles, una red donde los ciclos se observan y se corrigen entre sí en lugar de que un agente persiga un solo número.
Y los ingenieros rechazaron el revuelo en cuestión de horas, señalando que se trata de una idea de décadas de antigüedad que lleva un nuevo nombre. Tienen razón y esa es la buena noticia. Un patrón que ha ejecutado sistemas críticos durante treinta años es exactamente en lo que desea confiar su trabajo.
2 - Qué es realmente un gráfico.
Un gráfico es solo un plan para su trabajo de IA, elaborado para que pueda verlo. Responde a dos preguntas: qué trabajos deben realizarse y qué trabajo debe esperar a cuál.
Sólo hay dos partes, y aclararlas soluciona la mayor parte de la confusión.
Una caja se llama nodo. Es un solo trabajo: un agente que realiza una tarea, con una cosa entrando y otra saliendo. Investigando a un competidor. Escribir un borrador. Comprobando un reclamo.
Una flecha se llama arista. Simplemente significa que un trabajo necesita lo que otro trabajo produjo, por lo que tiene que esperarlo. Y la flecha sólo cuenta cuando algo real pasa por ella.
Los nodos hacen el pensamiento. Los bordes llevan los resultados. Ese es todo el vocabulario. Una vez que la tengas, nunca más necesitarás una definición.
Lo que hace que un nodo sea realmente utilizable en un gráfico es un contrato: un trabajo limitado, una entrada definida, una salida definida. Un nodo cuya salida es un muro de texto libre es un nodo que sólo un humano puede leer. Un nodo con una forma de salida fija es uno que el siguiente nodo puede consumir sin adivinar, que es el punto.
▸ NODE CONTRACT
JOB: research one competitor's pricing (one job, nothing else)
IN: { competitor: "name", url: "https://..." } ← passed in, never assumed
OUT: { price: number, plan: string, source: url, date: "YYYY-MM-DD" }
SCHEMA: enforced. if the agent returns free text, it's rejected and retried
WHY: a defined output is what lets the next node read this one
without a human in the middle. that is what makes it wire-able.
3 - La prueba que encuentra los bordes falsos.
Mire el flujo de trabajo de IA que ejecuta hoy y recorra paso a paso. En cada paso, pregunte una cosa: ¿este paso realmente necesita el resultado del anterior?
En caso afirmativo, la ventaja es real. Mantenga el orden. Si no, no hay ventaja y la espera es en vano. Esos dos trabajos se pueden ejecutar al mismo tiempo.
Tome uno simple: "revise el archivo A en busca de errores, luego revise el archivo B en busca de errores". Se lee como una secuencia, pero la verificación del archivo B nunca analiza qué archivo A devolvió. Solo se ejecutan uno tras otro porque ese es el orden en que los escribiste. Ejecútalos uno al lado del otro y todo terminará en el tiempo del archivo único más lento, no de los dos sumados.
Encontrarás dos o tres de estos bordes falsos en casi cualquier flujo de trabajo que dibujes. Cada uno de ellos es tiempo que estás desperdiciando gratis.
4 - Su configuración actual ya es un gráfico.
Cuando escribes un agente como "haz A, luego B, luego C, luego D", técnicamente ya has dibujado un gráfico. Es simplemente el más triste posible: una única cadena recta donde cada nodo tiene una flecha hacia adentro y una flecha hacia afuera.
Funciona correctamente. También corre lentamente y se rompe fácilmente, porque una cadena no tiene redundancia. Si C se detiene, D nunca sucede y el trabajo de A queda atrapado río arriba sin ningún lugar adonde ir.
La primera habilidad real de la ingeniería gráfica es volver a dibujar esa cadena. Tome su flujo de trabajo lineal y, para cada flecha, haga la pregunta falsa. Si se cortan las flechas que no contienen datos, la línea colapsa en algo más amplio: unos pocos trabajos independientes que pueden ejecutarse todos a la vez, alimentando un trabajo que los necesita todos.
La razón por la que esto es importante no es cosmética. Un flujo de trabajo lineal con 40 pasos tiene 40 puntos de falla secuencial y la latencia de los 40 sumados. Los mismos 40 trabajos dibujados como un gráfico tienen tantas dependencias reales como realmente existen, generalmente de tres a cinco, y terminan a la velocidad de la capa más lenta, no la suma de todo. Esa es la diferencia entre un trabajo que tarda cinco minutos y uno que tarda quince segundos, ejecutando exactamente el mismo trabajo.
El modelo nunca fue el cuello de botella. La línea que trazaste fue.
5 - El único patrón que paga: el diamante.
No necesitas cien formas. Observe cómo funciona cualquier sistema de agente serio y seguirá apareciendo la misma imagen. El trabajo se divide, varios trabajadores excavan uno al lado del otro, algo comprueba lo que han encontrado y todo vuelve a fusionarse en una sola respuesta.
Esa imagen se llama diamante y es casi el único patrón que necesitas este año. Vale la pena memorizar su nombre formal: desplegar, reducir, sintetizar.
Desplácese para ganar amplitud, reduzca con código simple para comprimirlo, sintetice con un agente final para escribir la respuesta.
La función de investigación dentro de Claude ejecuta exactamente esto en producción. Un jefe planifica los ángulos, los trabajadores se reúnen en paralelo, se comprueban los resultados y sólo entonces le llega un informe. Una vez que pueda ver el diamante, deje de preguntar "¿cómo hago para que mi agente realice más pasos?" y comience a preguntar "dónde está la división, dónde está la fusión". Esa segunda pregunta es la que escala.
Así es como se ve realmente el diamante debajo del capó. Cuando dices "flujo de trabajo", Claude escribe un script corto como este y ejecuta la coordinación como código, por lo que pasar resultados entre agentes no cuesta ningún contexto adicional.
// a market-scan graph — the diamond, written by Claude when you say "workflow"
const angles = [
"pricing vs the top 3 competitors",
"what buyers complain about in reviews",
"the feature gaps in the category",
"where the market moves in the next 12 months",
];
// FAN OUT — one researcher per angle, all at the same time
const raw = await parallel(
angles.map(a => () => agent({
task: `research: ${a}. every claim needs a source url + date.`,
schema: Finding, // validated output, not free text
model: "cheap", // boring node → cheap model
}))
);
// REDUCE — plain code, no model, no tokens
const findings = dedupeBySource(raw.flat().filter(Boolean));
// VERIFY — a FRESH skeptic per finding, tries to kill it
const survivors = await parallel(
findings.map(f => () => agent({
task: "try to disprove this. return keep | drop + why.",
input: f,
freshContext: true, // never reuse the researcher's chat
model: "strong", // judgment node → strong model
}))
).then(v => findings.filter((_, i) => v[i].verdict === "keep"));
// SYNTHESIZE — one agent writes the answer from what survived
return agent({ task: "one report, ranked by confidence, sources attached.",
input: survivors, model: "strong" });
Léelo una vez y todo el oficio será visible: el despliegue donde el trabajo es independiente, la reducción realizada en código libre, la verificación en un contexto nuevo, los modelos baratos en los nodos aburridos y el fuerte donde vive el juicio y una única síntesis al final. El mismo esqueleto detrás de un escaneo de mercado, una revisión de código o un informe de investigación. Intercambia los ángulos y las indicaciones.
6 - El corrector es todo el truco.
Ahora bien, la parte que casi todo el mundo se salta, y es lo que separa a una gráfica real de un juguete caro.
Cada prueba seria de autoevaluación de la IA dice lo mismo: los modelos pasan por alto la mayoría de sus propios errores. Un modelo que califica su propio trabajo es demasiado fácil consigo mismo.
Así que nunca dejas que el agente que hizo el trabajo revise el trabajo.
Pones un nodo separado en el borde. Su único trabajo es intentar acabar con el hallazgo antes de que siga adelante. Si sobrevive, pasa. Si no, muere allí mismo.
Aquí está el problema que nadie menciona: ese verificador necesita un contexto limpio.
Dale la misma conversación que tuvo el trabajador y no verifica nada, asiente con la cabeza con una fuente diferente. Un gráfico de agentes que comparten un contexto es solo un bucle en un disfraz, y se rompe de la misma manera, sólo que más tarde y más caro.
Así que actualice el verificador. Contexto propio. Verificar una señal real, no "el agente dijo que ya está hecho", sino "la prueba realmente pasó".
Luego divida la cuenta corriente en tres partes. ¿Es correcto? ¿Es actual? ¿Es la fuente siquiera real? Tres lentes diferentes captan lo que diez iguales no captan.
▸ VERIFIER NODE
INPUT: one finding from a worker (the finding only, never the worker's chat)
CONTEXT: fresh and empty. it has not seen the work it is judging
CHECKS: three skeptics run in parallel, each with a different question
1. is it correct? → does the claim actually hold up
2. is it current? → is the source recent, not something stale
3. is the source real? → does the link resolve to the claim it's cited for
PASS: keep the finding only if a majority of skeptics let it live
FAIL: drop it before it ever reaches the final answer
La regla a recordar: un trabajador y su verificador nunca deben compartir un contexto. En el momento en que lo hacen, vuelves a un bucle que califica su propia tarea, solo que con una factura más grande.
7 - Dónde realmente se rompen los gráficos.
- Colapso del contexto.
Distribuya mil nodos, luego intente alimentar todos los miles de resultados en un paso final y pasará la ventana de contexto antes de que comience la síntesis.
La solución: superponga su fan-in. Agrupe los resultados, resuma cada lote, luego combine los resúmenes, nunca la pila sin procesar.
// layered fan-in — never pour 1,000 raw outputs into one step
const batches = chunk(results, 40); // groups of 40
const summaries = await parallel(
batches.map(b => () => agent({ task: "summarize this batch", input: b }))
);
return agent({ task: "write the answer from the summaries", input: summaries });
// the final step reads ~25 summaries, not 1,000 raw outputs
- Falsa independencia.
Dos nodos parecen independientes porque sus mensajes nunca se mencionan entre sí, pero ambos escriben en el mismo archivo o acceden a la misma API de velocidad limitada. Ésa es una ventaja oculta.
Cuando el equipo de Bun desarrolló por primera vez un gran trabajo entre muchos agentes, compartieron un espacio de trabajo y se sobrescribieron entre sí.
La solución: dar a cada trabajador su propio espacio aislado y auditar los recursos compartidos, no solo los datos compartidos.
// isolate the workers — no shared file, no shared workspace
await parallel(files.map(f => () => agent({
task: `refactor ${f}`,
worktree: true, // each agent works in its own git worktree
})));
// they can't overwrite each other, then the results merge cleanly
// rule: any two nodes writing the same file need an edge, not parallelism
- Fallo del nodo silencioso.
En una cadena, un fallo lo detiene todo, molesto pero evidente. En un gráfico, un nodo muerto entre doscientos puede aparecer en un informe que parece completo.
La solución: cada paso de fusión cuenta sus entradas con el número esperado y marca la brecha en lugar de ejecutar silenciosamente la mitad de los datos.
// fan-in guard — catch the node that quietly died
const results = (await parallel(jobs)).filter(Boolean); // dropped nodes = null
if (results.length < jobs.length) {
flag(`WARNING: ${jobs.length - results.length} of ${jobs.length} nodes returned nothing`);
}
// never synthesize on a partial set and call the report complete
8 - ¿Necesitas uno?
Como es tradición en mis artículos, averigüemos honestamente para quién podría resultar útil.
Un gráfico compra amplitud. No se compra un mejor juicio.
Es una herramienta de ancho, para trabajos independientes realizados de una vez. Cuando el trabajo no es amplio, la línea nunca fue el problema.
Omita el gráfico cuando:
- La tarea es pequeña o aislada. Agregar una función, corregir un error. La coordinación es puramente general y un solo agente es más rápido y económico.
-
Quieres aprobar cada paso. El objetivo de un gráfico se desvía sin ti, por lo que una correa apretada va en su contra.
-
Aún no sabes lo que estás buscando. El trabajo exploratorio necesita un agente al que puedas dirigir, no una flota encerrada en un plan.
-
Los pasos realmente dependen unos de otros. Forzar un gráfico a un trabajo verdaderamente secuencial solo agrega costos para una aceleración cero.
-
La prueba es la prueba del borde falso. Si no puede encontrar dos trabajos sin ninguna ventaja entre ellos, no hay ningún gráfico que construir. Es un bucle y un bucle está bien.
9 - La parte que nadie quiere escuchar: las anclas.
Aquí hay una trampa más profunda y es la verdadera lección de todo este cambio.
Imagina que construyes el gráfico completo. Comprobadores emparejados, nodos de auditoría, metanodos que sintonizan los otros nodos. Cada nodo observa a otro nodo y cada uno de ellos lee un informe.
La auditoría compara las cifras con las cifras financieras, que provienen del mismo sistema en primer lugar.
Todo es consistente. No se verifica nada.
Este gráfico falla exactamente como lo hizo el bucle único, un poco más tarde, más caro y con muchas más luces verdes en el camino hacia abajo.
La topología por sí sola no compra la verdad. El gráfico necesita anclas: nodos con los que no se pueda discutir.
Las pruebas que realmente se ejecutaron, no "deberían pasar", sí pasaron. Ingresos que aterrizaron en el banco. Clientes que realmente se quedaron.
Y algunas reglas deben congelarse, aquellas que un optimizador estaría tentado a debilitar, mantener fuera de los límites precisamente porque son las que se doblegaría para ganar.
El gráfico es tan honesto como las cosas que hay dentro de él y que se niegan a moverse.
Juzguelo en base a números que no pueden argumentar y se mantendrá firme. Dejemos que califique sus propios informes y seguramente se equivocará.
10 - Construya uno usted mismo en Claude Code.
Basta de teoría. Si ha decidido que esto es para usted o simplemente quiere probarlo, creemos uno. Puede crear un gráfico real en un par de minutos, porque Claude Code envió las herramientas para hacerlo directamente, llamadas flujos de trabajo dinámicos.
Todo se reduce a una palabra: "flujo de trabajo".
Póngalo en su mensaje y Claude dejará de seguir una sola línea de pasos. En lugar de eso, escribe un breve script de orquestación y luego genera una flota coordinada de subagentes para ejecutarlo.
Lo importante es que la coordinación es un código, no una conversación. Pasar resultados entre agentes no vuelve a utilizar su contexto como lo hace una transferencia de chat, que es lo que permite que una ejecución escale a una flota completa sin ahogar la sesión.
Abre un repositorio real que conozcas y pega esto:
▸ GRAPH SPEC
GOAL: audit every route file under src/routes/ for missing auth checks
FAN OUT: one agent per file, all running in parallel
VERIFY: an independent checker on each finding, with fresh context
CAP: 20 files on this first run
ON FAIL: flag any file that doesn't return, never skip it silently
REPORT: one merged list of the routes missing auth
(start the prompt with the word "workflow" so Claude builds the graph)
Ejecútelo y esto es lo que sucede.
Primero, Claude indica que está creando un flujo de trabajo en lugar de responder en un chat normal y le muestra el plan antes de hacer cualquier cosa. Lo lees y lo apruebas.
Entonces la flota se pone en marcha. Un agente por archivo, todo al mismo tiempo, mientras su propia sesión permanece libre durante todo el proceso.
Y lo que llega al final no son veinte chats separados para explorar. Es un informe. Los resultados intermedios vivían dentro del guión, nunca en tu contexto, por lo que lo único que realmente ves es la respuesta final.
Eso es un gráfico. Una docena de agentes de una sola sentencia. Cuando una ejecución sale bien, guárdela y se convertirá en un comando que podrá volver a ejecutar por nombre para siempre.
Observe el límite de "20 archivos" en ese mensaje. Mantiene su primera ejecución barata y da pistas de lo que toda demostración omite: la factura.
11 - Gráficos listos que puedes pegar de inmediato.
Cada uno de ellos es el mismo diamante destinado a un trabajo diferente. Abra Claude Code en una carpeta real, intercambie las partes entre corchetes por las suyas y péguelas. La palabra "flujo de trabajo" es lo que le dice a Claude que construya una flota coordinada en lugar de una sola línea de pasos. Manténgase como el último sí antes de que se envíe algo.
Un escritorio de investigación con grado de decisión. Reemplaza una semana de búsqueda en Google o una costosa factura de analista. Su pregunta se divide en ángulos, los investigadores excavan a la vez, un escéptico ataca cada hallazgo y sólo los supervivientes llegan al informe.
▸ GRAPH SPEC
GOAL: decision-grade research on [your question]
FAN OUT: split into 5 distinct angles, one researcher per angle, in parallel
RULE: every finding needs a source link and a date
VERIFY: a skeptic attacks each finding and tries to disprove it, drop what fails
MERGE: survivors into one report ranked by confidence
SAVE: research-report.md, then show me the top findings
HUMAN GATE: change nothing after that without asking me
(start the prompt with the word "workflow" so Claude builds the graph)
Una máquina de contenidos SEO. Escribe un borrador listo para clasificar por ejecución y nunca lo publica sin usted.
▸ GRAPH SPEC
GOAL: one ranking-ready draft for [topic]
PARALLEL JOBS (run at once):
1. what the current top-ranking pages cover
2. the real questions people ask about this topic
3. what those top pages skip
MERGE: the three into an outline, then write a full draft
VERIFY: a fact-checker that flags every claim without a source
SAVE: drafts/ with the flagged claims listed at the top
HUMAN GATE: never publish anything
(start the prompt with the word "workflow" so Claude builds the graph)
Un kit de comercialización. El paquete de lanzamiento completo en una sola ejecución, y usted aprueba cada pieza.
▸ GRAPH SPEC
GOAL: full launch kit for [product], aimed at [audience]
PARALLEL JOBS (research, run at once):
1. profile the buyer and the exact words they use
2. map where these buyers spend time online
3. collect how competitors pitch them
MERGE: a one-page positioning doc
HUMAN GATE: pause and show me the positioning doc before writing
PARALLEL JOBS (writing, from that doc):
1. landing page copy
2. a week of launch posts
3. a set of outreach messages
VERIFY: a checker compares every asset to the positioning doc, flags anything off
SAVE: launch-kit/, change nothing after that without asking me
(start the prompt with the word "workflow" so Claude builds the graph)
Una refactorización barre todo un repositorio. Amplitud que ningún contexto por sí solo podía contener.
▸ GRAPH SPEC
GOAL: find every function over 100 lines and propose a refactor for each
FAN OUT: one agent per file, in parallel
VERIFY: an independent checker on each proposed refactor, fresh context
DEDUPE: proposals against everything already seen
CAP: 50 files on this first run
REPORT: how many files came back, so nothing fails silently
(start the prompt with the word "workflow" so Claude builds the graph)
Un bucle de descubrimiento de tamaño desconocido. Para trabajos en los que no sabes qué tan grande es el trabajo hasta que estás en él, como un barrido de errores donde al encontrar un error se revelan tres más.
▸ GRAPH SPEC
GOAL: hunt this repo for [security issues / broken error handling / dead code]
FAN OUT: run finders in parallel
DEDUPE: check each new find against everything already seen
VERIFY: an independent checker on the survivors
LOOP: keep going until two rounds in a row find nothing new, then stop
CAP: a hard limit on total agents so it can't run away
REPORT: final list ranked by severity
(start the prompt with the word "workflow" so Claude builds the graph)
Run one scoped, watch what it costs, then widen. When a run is good, save it, and every one of these becomes a single command you launch by name.
12 - El costo y la supervisión.
Un gráfico cuesta más que un chat normal. Mucho más. Lo que sale más barato es la coordinación, no el trabajo en sí. Los agentes todavía queman fichas y una flota de ellas quema una pila.
El ejemplo más claro es el público. Un ingeniero utilizó esta configuración exacta para reescribir el tiempo de ejecución de Bun, traduciendo alrededor de 535.000 líneas de un idioma a más de un millón de líneas de otro en aproximadamente once días. A mano que es cerca de un año de trabajo.
Ejecutó alrededor de 50 flujos de trabajo, con hasta 64 agentes funcionando a la vez.
También costó aproximadamente $ 165,000 en uso, necesitaba un ser humano para diseñar y observar todo, y recibió críticas reales sobre si tanto código escrito por IA se puede revisar de manera segura.
Esa es la forma honesta de esto. Un gráfico puede extenderse a mil agentes y analizar un trabajo que ningún contexto por sí solo podría realizar. También puede gastar silenciosamente su dinero en segundo plano si apunta a la tarea equivocada o se salta las anclas.
Entonces, la versión pesada es para equipos con el presupuesto, los límites y el monitoreo para ejecutarla. Si aún no eres tú, no te falta nada. Empiece poco a poco, observe lo que cuesta una carrera y amplíe sólo una vez que uno se lo haya ganado.
13 - Qué significa esto realmente para ti.
Ese es el panorama completo. Ahora sabes qué es un gráfico, dónde brilla, dónde se rompe y para quién es en realidad.
Ya conoces el punto fuerte: la amplitud, el trabajo independiente y hecho a la vez. Y la debilidad: compra amplitud, no juicio, y gastará su dinero si lo apunta al trabajo equivocado.
Entonces la medida no es graficar todo. Es saber cuándo el trabajo es lo suficientemente amplio como para necesitar uno y cuándo un simple bucle fue la respuesta desde el principio.
Mi opinión: aprende la prueba del borde falso esta noche. Dibuje su flujo de trabajo actual, busque los bordes que no contienen datos y elimínelos. Ese movimiento te hace más rápido que la mayoría de las personas antes de tocar una sola herramienta nueva.
La mayoría seguirá haciendo cola en una fila. Los pocos que aprendan a dibujar el gráfico dirigirán una flota.
Si quieres estar al día de todo lo que sucede en IA, sígueme en X y Telegram:
X-https://x.com/AnatoliKopadze
Telegrama: https://t.me/kopadzemp