¿Por qué en QuickFigen la IA edita diagramas sin regenerar?

Cuando preparaba problemas de física para mis estudiantes de bachillerato, casi siempre necesitaba construir diagramas. Solía usar herramientas bien conocidas, e incluso recurría a la IA.

Las herramientas tradicionales son generalistas. Construir un diagrama de física tomaba tiempo: ajustar elementos uno por uno, alinear vectores, nombrar etiquetas. Diez minutos para algo que en mi cabeza era simple.

Con IA pasaba algo distinto, pero igual de frustrante. El primer resultado, aunque era de buena calidad, no coincidía con lo que tenía en mente. Escribía un prompt nuevo con ajuste. Tampoco. Otro prompt, otro intento. El ciclo terminaba en frustración: cada nueva versión perdía algo de la anterior.

La IA no estaba editando; estaba reescribiendo desde cero cada vez.

El problema no es la calidad de la IA. Era cómo está pensada: para regenerar, no para editar.

Ahí pensé en una plataforma distinta: una que produjera escenas editables, no imágenes. Donde el usuario pudiera modificar elementos directamente, y donde la IA, en lugar de regenerar todo, hiciera cambios puntuales sobre el estado actual.

Esa idea inspiradora es uno de los motivos por los que estoy construyendo QuickFigen.

Un ejemplo concreto

Imaginemos que un docente arma un plano inclinado a 35°. Le agrega un bloque grande cuya masa lo etiqueta como "M". Dibuja dos vectores: peso (Mg) y la normal (N). Cada uno con su color, su grosor, el tipo de flecha, el largo de la flecha, etc. Le tomaría cinco minutos llegar al estado que quiere para la pizarra del día siguiente.

Le pide a la IA: "agrega fricción al bloque".

Si la herramienta regenera, como hacen la mayoría de productos que dicen "edita con IA", la respuesta vuelve cambiada por completo. La etiqueta del bloque ahora puede decir "m1"; el ángulo puede haber cambiado a 30°; la fuerza aplicada pudo haber desaparecido. Aparece un vector de fricción, sí. Pero todo lo demás se reescribió.

Si la herramienta edita —como lo hace QuickFigen— solo aparecería el vector nuevo. El bloque seguiría siendo "M"; el ángulo seguiría siendo 35°. La modificación es aditiva: agrega lo nuevo sin tocar lo previo.

Por qué pasa esto

La mayoría de productos que dicen "edita con IA" en realidad regeneran. Cuando se les pide un cambio, internamente le envían al modelo el prompt original más el cambio nuevo, y devuelven un output entero. La interfaz lo presenta como "edición" porque la pantalla parpadea y aparece algo similar a lo de antes — pero por detrás, lo previo se descartó. El modelo nunca tuvo memoria del trabajo anterior, solo de las palabras que lo describían.

Esto pasa por una razón estructural, no por descuido. Los modelos generativos funcionan sin memoria real entre llamadas. Cada vez que les pides algo, es como empezar de nuevo. La "consistencia" entre llamadas es estadística, no determinista. Si el modelo dibujó "M" la primera vez, hay una probabilidad alta de que lo haga otra vez con el mismo prompt, pero hay una probabilidad, aunque baja, de que cambie la etiqueta por otra: "m₁", "m_1" o "block_a", etc.

El costo invisible para el usuario es importante: no se puede construir incrementalmente. Cada prompt es como lanzar dados: no siempre obtienes lo mismo. Cuanto más complejo es el output, más drift (diferencia) hay entre los resultados. Para un escritor que itera un párrafo, el drift es manejable, los errores se ven y se corrigen. Para un docente que arma un diagrama con etiquetas precisas, IDs internos y relaciones físicas entre objetos, el drift hace que el diagrama que se construya se distorsione cada vez más.

La decisión: el JSON es el dueño, no la IA

Cuando arranqué QuickFigen tomé una decisión que ahora suena obvia, pero en ese momento no lo era:

la IA no es la parte central del proceso de generación de imagen, sino solo una parte de dicho proceso (pipeline)

Eso cambia todo.

En la mayoría de herramientas, la IA es quien genera el resultado final. En QuickFigen no. La IA solo sugiere cambios.

Hay una representación interna —un JSON— que describe la escena completa: qué objetos hay, cómo se relacionan, qué propiedades tienen. Un JSON es simplemente un archivo de texto estructurado, como una lista detallada de todos los elementos del diagrama y sus características. Ese JSON es la fuente de verdad.

Cuando mueves un objeto, cuando cambias un valor, cuando ajustas algo en pantalla, lo que realmente está cambiando es ese JSON.

La IA entra solo cuando se le pide algo en lenguaje natural. Y cuando entra, no devuelve una escena nueva, sino devuelve instrucciones sobre la escena actual. Algo como: “agrega este vector”, “modifica este valor”, “elimina este objeto”.

Técnicamente es un JSON Patch sobre el estado existente.

No rehace el diagrama. Lo modifica.

{
  "stage": "patch",
  "patches": [
    {
      "op": "add",
      "path": "/objects/-",
      "value": {
        "id": "frictionVec1",
        "type": "Vector",
        "appliedTo": "block1",
        "label": "f",
        "directionDeg": 145,
        "magnitude": 12,
        "quantity": "force"
      }
    }
  ]
}

Esto es lo único que cambia: una operación local sobre toda la escena de objetos. La etiqueta del bloque sigue siendo "M", el ángulo del plano sigue igual, etc. Solo cambia lo que se le indique que cambie. En este ejemplo, lo único nuevo es el vector de fricción, agregado al final del array objects en el JSON.

El modelo no inventa una escena nueva. Mira la escena actual como contexto, decide qué patch corresponde al pedido del usuario, y emite ese patch. Si el patch sale roto, no se aplica — el JSON no cambia. Si sale bien, se aplica como cualquier edición manual.

¿Qué impacto tiene en la experiencia del usuario esta decisión?

Una vez que el JSON es la fuente de verdad, varias cosas que parecían imposibles se vuelven triviales.

Cadenas largas de modificación

Cuando tengas una escena, le puedes pedir a la IA de manera secuenciadamente. Por ejemplo, esta es una secuencia real, sobre un plano inclinado:

1. Prompt 1: "Haz un plano inclinado de 35° con un bloque encima."
2. Prompt 2: "Agrega un segundo bloque más pequeño arriba del primero."
3. Prompt 3: "Muestra el diagrama de cuerpo libre del bloque grande."
4. Prompt 4: "Cambia el ángulo a 28°."
5. Prompt 5: "Agrega fricción entre el bloque grande y el plano."
6. Prompt 6: "Quita la fricción."

Cada paso solo cambia lo que pidió. Después del paso 5, el bloque grande sigue teniendo la misma masa que se le asignó, el bloque pequeño sigue arriba, el DCL sigue mostrando los mismos vectores que ya estaban, los IDs no cambiaron. Después del paso 6, la fricción desaparece. Lo demás permanece exactamente como estaba en el paso 5 (con el ángulo a 28°, los dos bloques, el DCL del bloque grande, los vectores de peso y normal). No es un undo del último cambio entero, es eliminación selectiva del objeto fricción mientras todo lo demás se preserva.

En un producto que regenera, los pasos 4 a 6 perderían etiquetas, posiciones, colores. Cada cambio reinicia el contador.

Ediciones aditivas y reversibles

Esta es una de esas características de QuickFigen (QF) que lo hace muy interesante y atractivo. Como el cambio que hace la IA es una operación discreta, focalizada en ciertos objetos, se puede deshacer. La opción de añadir o quitar objetos a la escena no es a nivel de bitmap (como ocurre en la mayoría de plataformas con IA), sino que es a nivel de objeto.

Y como el JSON sobrevive entre prompts, se puede mezclar libremente: arrastrar un objeto con el mouse desde el panel de herramientas, modificar alguna propiedad del objeto desde el panel de propiedades o usar el asistente de IA para agregar, quitar o modificar propiedades y/o objetos. Las tres operaciones tocan el mismo JSON, en cualquier orden. No hay "modo IA" frente a "modo manual" — todo es la misma cosa.

Preservación de contexto

Esto es lo que más cuesta explicar pero es lo que más se siente. Cuando se trabaja sobre el mismo objeto durante minutos —ajustando masa, cambiando color, moviendo etiqueta, agregando un vector—, esos ajustes son la intención específica del docente. Son las decisiones pedagógicas para esta clase puntual: este bloque se llama M porque se va a comparar con m del próximo problema; este color es rojo porque marca la fuerza neta. Si la próxima edición arrasa con eso, se perdió la intención. Hay que reconstruirla. Y la fricción de reconstruirla cada vez es lo que hace que muchos docentes terminen prefiriendo PowerPoint.

Exportación reproducible

El JSON es serializable. Eso significa que un diagrama es un archivo. Se guarda, se comparte, se abre el próximo año, y aparece exactamente igual — porque el renderer es determinista sobre el JSON. No hay "se ve un poco distinto que la última vez". No hay "ah, parece que la IA esta vez interpretó diferente". El diagrama de marzo de 2026 que se abre en marzo de 2027 es el mismo diagrama. Y se puede seguir editando.

Esto importa más de lo que parece: convierte la biblioteca de diagramas del docente en un archivo duradero, no en una colección de outputs efímeros que tendría que recrear cada vez que quiere cambiar algo.

¿Por qué esto es crítico para la enseñanza?

Aquí va la parte que aprendí enseñando física, no programando.

Un docente nunca arma un diagrama una sola vez. El ciclo real es: construir → ajustar → variar → reusar.

El docente construye el diagrama base. Lo ajusta durante la clase. Lo varía esa misma semana para otros ejercicios. Y lo reutiliza el siguiente año.

Si cada modificación implica un riesgo de perder lo previo, el ciclo se rompe. Lo que pasa en la práctica es que el docente se queda en construir: arma el diagrama, lo guarda como imagen, y la próxima vez que necesita una variación construye otro desde cero. La fase ajustar / variar / reusar nunca arranca, porque el costo es demasiado alto.

Por el contrario, cuando la edición es genuinamente aditiva, el ciclo fluye. Se empieza con el diagrama del año pasado, se le pide a la IA que cambie un par de cosas para esta cohorte, se ajusta a mano, y en treinta segundos hay algo que antes tomaba quince minutos.

Es una diferencia pequeña en cada operación individual. En un semestre, son docenas de horas.

Lo que cuesta tomar esta decisión

No quiero que esto suene como la solución perfecta. No lo es. Tiene tres costos reales que vale la pena hacerlos explícitos.

Costo 1: más trabajo de ingeniería. Trabajar con un JSON como fuente de verdad significa que cada nuevo objeto que entra al sistema requiere trabajo de fondo: definir cómo se representa, cómo se valida, cómo se renderiza, cómo se edita, y cómo la IA puede modificarlo sin romper nada. Es más lento construir features que en un sistema regenerativo, donde solo le dices al modelo "ahora también genera esto".

Costo 2: rigidez en lo que el sistema acepta. Para que funcione, los objetos tienen que tener significado claro. Un plano no es "una forma": es una superficie con un ángulo y una orientación física. Un vector no es "una flecha": es una fuerza, una velocidad, algo que actúa sobre algo. No puedes dibujar cualquier cosa libremente. Pero en física, esa rigidez es exactamente lo que permite que el diagrama se comporte coherentemente.

Costo 3: límites operativos honestos. Hay cosas que el sistema simplemente no hace. Si pides "hazlo más bonito" o "hazlo más profesional", no hay operación específica que mapee a esa instrucción. Esa subjetividad visual implicaría rehacer la escena, que es justo lo que estamos evitando.

A pesar de las limitaciones, ¿por qué igual la elegí?

Porque conozco cómo trabaja un docente en la práctica. El problema no es hacer un diagrama una vez. Es poder volver a él meses después y seguir trabajándolo sin empezar de cero.

Un sistema que regenera puede impresionar en el primer click, pero es casi insostenible en el tiempo, cuando necesitas construir diagramas por etapas. Además, para enseñar, lo que importa no es el primer click, es todo lo que viene después. Por eso tomé esta decisión.

La IA es útil. Pero no es el sistema. Es solo una forma de interactuar con él.