Versión 9 · 16/11/2026 · 36 capítulos
Para entenderCapítulo 1 · Vigente al 16/11/2026
La plataforma hace una sola cosa, en cinco pasos: un tutor carga una hoja de ejercicios, el alumno la resuelve en papel, le saca una foto, la app corrige renglón por renglón y le enseña lo que le faltó.
Cada paso es un módulo. Los módulos se pasan el trabajo en ese orden, y por debajo hay tres capas que los atraviesan a todos: lo que la plataforma sabe del alumno, el registro de todo lo que pasó, y la puerta única por donde salen las consultas a la inteligencia artificial.
| De | A | Qué le entrega |
|---|---|---|
| Cargar la tanda | Armar la sesión | Los ejercicios leídos, con su resultado verificado y las habilidades que exige cada uno |
| Armar la sesión | El ojo | El ejercicio que le toca ahora al alumno |
| El ojo | La corrección | Los renglones tal como el alumno los confirmó |
| La corrección | La enseñanza | Dónde está el error, de qué tipo es y qué habilidad falló |
| La enseñanza | El perfil | Qué se le explicó y si después el error volvió |
| El perfil | Armar la sesión | Qué conviene que practique la próxima vez |
La última fila es la que cierra el círculo: lo que el alumno hace hoy cambia lo que la app le va a dar mañana.
Ninguna regla de enseñanza vive dentro de una consulta a un modelo. Qué se considera dominado, cuándo toca un repaso, qué cuenta como error y cuándo frenar son decisiones del programa, escritas en código y con pruebas. A los modelos se les pide redactar un texto, leer una foto o proponer un ejercicio; lo que devuelven, el programa lo acepta o lo rechaza.
El documento usa siempre las mismas palabras para las mismas cosas. Estas son las que más vuelven. No hace falta aprenderlas de memoria: cada capítulo las explica otra vez cuando las necesita.
| Palabra | Qué quiere decir |
|---|---|
| Tanda | El conjunto de ejercicios que un adulto sube de una vez, normalmente una hoja de tarea. Tiene los que se subieron, ni más ni menos |
| Sesión | Un rato de práctica del alumno. Puede tener ejercicios de varias tandas, y puede pausarse y retomarse |
| Habilidad | Una cosa concreta que se sabe hacer, por ejemplo «pasar a denominador común». Cada renglón de una cuenta usa una o varias |
| Estadio | Cuánto parece saber el alumno una habilidad, de 0 a 4. Del 0 («nunca le salió») al 4 («le salió días después, mezclada y sin ayuda») |
| Ocasión | Un ejercicio distinto en el que apareció una habilidad. Varios renglones del mismo ejercicio son una sola ocasión, no varias |
| Repaso | Un grupo de ejercicios con fecha, que vuelve días después de terminar una tanda para ver si lo practicado quedó. Cada tanda tiene hasta tres |
| Parecido | Otro ejercicio del mismo tipo con otros números, que arma la plataforma sola cuando algo no salió o cuando hace falta otra ocasión |
| Gemelo | Lo mismo, pero pedido a mano por un adulto con el botón «Dar un gemelo». Exige más: cambia cómo está organizada la cuenta, no solo los números |
| Patrón | Lo que se ve en la hoja: «sumó arriba con arriba». Es la descripción del error, sin suponer por qué pasó |
| Causa | Por qué pasó ese error: la idea equivocada que hay detrás. Una causa solo se da por buena cuando el alumno la confirma o la cuenta no deja otra opción; mientras tanto es una sospecha |
| Certeza | Qué tan segura está la plataforma de algo: alta, media o baja. Hay una certeza para lo que leyó de la foto, otra para la corrección y otra para la causa, y nunca se mezclan en un número solo |
| Previa | Lo que hay que saber antes: sumar es previa de restar. Sirve para saber dónde mirar cuando algo falla |
| SOS | El botón con el que el alumno pide ayuda. La plataforma no interrumpe sola mientras trabaja: la ayuda llega cuando él la pide |
| Tope | Un límite de gasto en inteligencia artificial. Hay uno por consulta, uno por alumno y uno de emergencia |
| Freno | Una función que queda apagada hasta que los números muestren que la plataforma acierta lo suficiente como para encenderla |
| El verificador | El programa que rehace cada cuenta con matemática exacta —fracciones de verdad, no decimales redondeados— y dice si un renglón vale lo mismo que el anterior. No es una IA, y en matemática su palabra es la última |
| Devolución | Lo que el alumno recibe cuando cierra un ejercicio: qué renglón está mal, por qué, y cómo se hace. Nunca el resultado suelto |
| Pista | Una ayuda corta que señala dónde mirar sin decir qué está mal. Es el escalón más bajo de la ayuda |
| Lección | Un escalón más arriba: le muestran resuelto, paso a paso, un ejercicio del mismo tipo con otros números. Ese no lo resuelve él y no cuenta como práctica |
| Consejo | La frase que le diría un maestro sentado al lado, atada al tipo de error que cometió: «antes de calcular, fijate si la base es negativa» |
| Pizarrón | La cuenta resuelta paso a paso que el alumno puede ver recién cuando el ejercicio ya cerró |
| Tarjeta | Cada cosa que el alumno puede tocar para empezar en su pantalla de inicio: una tanda nueva, algo para retomar, un repaso |
| Firme y dominado | Dos cosas distintas. Firme es lo que le salió hoy. Dominado es lo que volvió a salirle días después, mezclado con otros temas y en otro ejercicio. Toda la plataforma gira alrededor de esa diferencia |
| La puerta de la IA | El único lugar del programa por donde salen las consultas a una inteligencia artificial. Ahí se controla a qué empresa se le puede mandar qué, se reserva el gasto y se registra todo, aunque la consulta falle |
| Pendiente | Algo que quedó sin terminar y la plataforma no olvida: un ejercicio que no salió, un repaso sin hacer |
Para entenderCapítulo 2 · Vigente al 16/11/2026
Un chico hace su tarea de matemática en papel, como siempre. Le saca una foto. La plataforma la lee, la corrige renglón por renglón, le dice dónde está el error —sin decirle el resultado— y le vuelve a traer eso mismo días después para ver si de verdad le quedó.
Del otro lado, un tutor ve qué pasó, cuánto trabajó, qué le costó y si está aprendiendo. Nada más: no corrige, no tiene que saber matemática, no tiene que estar sentado al lado.
| Quién | Qué hace | Qué ve |
|---|---|---|
| El alumno | Practica. Saca fotos, corrige, pide ayuda cuando la necesita | Sus tarjetas, su ejercicio, su devolución. Nada más |
| Los tutores | Cargan las tandas, arman sesiones, miran cómo va, deciden | Todo lo de sus alumnos |
| Quien construye | Programa, prueba y publica, siempre con autorización | El código y las decisiones; nunca datos reales sin permiso |
| Quien decide | Aprueba qué se construye, qué se publica y los textos que ve el alumno. No programa ni corrige matemática | Todo |
Hay una asimetría deliberada: el alumno ve muy poco. No hay notas, ni cronómetro, ni colores de rendimiento, ni informes, ni su perfil, ni los costos, ni la respuesta correcta suelta. Y no es que estén escondidos detrás de un permiso: esas pantallas no existen para él.
Cinco partes. La primera explica qué es, en qué investigación se apoya y qué reglas no se tocan. La segunda sigue un ejercicio desde que se carga hasta que se cierra: es el corazón. La tercera cuenta lo que ven los tutores. La cuarta, cómo está construido. La quinta, cómo se trabaja sobre esto.
Cada capítulo empieza con un «En simple» que se puede leer solo, y termina con un bloque plegado —«Todos los casos»— con el detalle exacto de cada situación y cada botón. Quien quiere entender, lee la primera parte de cada capítulo; quien tiene que trabajar sobre algo, abre la segunda.
SigueCapítulo 3 · Los principios de diseñoPara entenderCapítulo 3 · Vigente al 16/11/2026
Casi todas las decisiones raras de esta plataforma —por qué espera, por qué no dice el resultado, por qué recalcula todo, por qué pregunta antes de corregir— salen de seis ideas. Si se entienden estas seis, el resto del documento se vuelve previsible.
Las seis no se inventaron acá: cada una se apoya en investigación sobre cómo se aprende, y el capítulo siguiente —En qué se apoya— dice de dónde sale cada una y dónde la plataforma va más allá de lo que la evidencia respalda.
Un chico que resuelve bien diez ejercicios iguales seguidos puede no haber aprendido nada: aprendió a repetir ese ejercicio. Por eso la plataforma mide otra cosa.
Si la plataforma dice el resultado, el ejercicio se termina. Por eso el resultado está protegido por varias capas: el texto que va a la pantalla pasa por un filtro que busca el resultado en todas sus formas —3/4, 6/8, 0,75, «tres cuartos»—, y la resolución completa se ve recién cuando el ejercicio cerró.
La ayuda va de menos a más: confirmar lo que escribió, marcar el renglón sin decir qué está mal, preguntarle cómo lo pensó, una lección que le muestra resuelto un ejercicio del mismo tipo, y por último un parecido para que lo intente él. Cada escalón da un poco más, y solo cuando el anterior no alcanzó.
Mientras el chico trabaja, no se lo interrumpe. No hay un cartel que salte a mitad de un renglón diciendo «ojo con eso». La ayuda llega cuando la pide, y la devolución completa al cerrar el ejercicio.
Frenarlo en vivo —avisarle en el momento en que se equivoca— es algo que llega mucho más adelante, tema por tema, y solo cuando los números muestren que para ese tema la plataforma acierta lo suficiente. Avisar mal en el momento equivocado es peor que no avisar.
Es la regla que más código genera. Nada de lo que ve el chico se muestra sin pasar todos sus controles, y ante la duda se suman controles; si la duda sigue, no se muestra.
Está escrito así, en estas palabras: el costo no es motivo para sacar un control ni para mostrar algo dudoso. Si no da buena información, nada sirve.
Eso es lo que se compra con lo que cuesta: dos lectoras de la hoja en vez de una, un revisor de una empresa distinta de la que escribió el texto, y una verificación matemática exacta de todo lo que devuelve una IA. Cuesta más y tarda más, a propósito.
Y hace posible lo que termina de cerrar la regla: cuando después de todos los controles la plataforma no está segura, dice «no pude» en vez de inventar algo. Esa también es una respuesta correcta, y es preferible a una equivocada dicha con seguridad.
De acá salen también dos reglas sobre quién decide qué:
Nada se borra: se anula con un motivo, y la anulación es un hecho más. Todo lo que la plataforma concluye —el perfil, el estado de cada ejercicio, los informes— se calcula desde esa historia, entera, cada vez.
Eso hace posibles tres cosas que de otro modo no lo serían: explicar por qué la plataforma concluyó algo, arreglar un error del pasado contándolo en vez de parchearlo, y cambiar una regla y volver a aplicarla hacia atrás.
También queda escrito lo que no se mostró: una respuesta de una IA rechazada se guarda completa, con quién la dio, cuánto costó y qué se hizo con ella. Es la base para decidir, más adelante, si pagar un modelo caro tiene sentido.
La plataforma está pensada para un adulto que no es programador ni matemático. Entonces:
No son una declaración: se ven. Un filtro que busca el resultado en todas sus formas. Una espera que se abre antes de confirmar. Una tabla donde la base no deja borrar. Un rol de IA que no se puede llamar sin la imagen. Un tope de 90 segundos que prefiere una salida clara a una respuesta perfecta tarde.
Y cuando un principio choca con otro —la velocidad contra la verificación, el costo contra el control—, hay un orden: primero que la información sea verdadera, después que no trabe al chico, después todo lo demás.
SigueCapítulo 4 · En qué se apoya: la evidenciaPara entenderCapítulo 4 · Vigente al 16/11/2026
Casi nada de lo que hace la plataforma se inventó acá. Esperar días para repasar, mezclar temas, no decir el resultado, no elogiar al chico sino el trabajo: cada una de esas decisiones sale de investigación sobre cómo se aprende, y acá está escrito de dónde.
También está escrito lo contrario: dónde la plataforma hace algo que la evidencia no respalda. Esos casos llevan un recuadro de aviso, acá y en el capítulo donde aparecen. No son errores: son apuestas, y conviene saber cuáles son.
Cada fila dice la idea, qué dice en simple, qué regla de la plataforma la usa y de dónde sale. El detalle de cada estudio está en los informes del proyecto, sobre todo en el informe 5.
Casi toda esta evidencia viene de aulas y de otros países, no de un chico practicando solo en su casa. Que un efecto aparezca con 787 alumnos de séptimo grado en un estudio no garantiza que aparezca con un chico en su escritorio.
Por eso ninguna de estas ideas se da por cierta: la plataforma mide con el alumno si funciona, y los números que usa son valores de arranque que se corrigen con lo que pase.
| Idea | Qué dice, en simple | Qué hace la plataforma | De dónde sale |
|---|---|---|---|
| Repaso espaciado | Se recuerda mejor si se repasa días después que si se practica todo junto el mismo día | Los repasos son grupos de ejercicios con fecha, que van en orden. Por defecto a los 2, 5 y 14 días encadenados, que sin atrasos caen en los días 2, 7 y 21 | Metaanálisis de Murray, Horner y Göbel (2025): 27 estudios en matemática, efecto robusto |
| Práctica mezclada | Mezclar temas cuesta más mientras se practica, pero se aprende más, porque hay que darse cuenta qué procedimiento usar | Los repasos vienen mezclados con otros temas y sin título que delate de qué son | Rohrer y colegas (2020): 787 alumnos de 7.º grado; un mes después, 61 % de aciertos contra 38 % de la práctica en bloque |
| Recuperar de memoria | Intentar acordarse solo fija más que releer o mirar el ejemplo | Las comprobaciones de los repasos van sin ayuda | Informe 5, tema 4. Con reparo: en matemática lo más probado es espaciar y mezclar; «ponerse a prueba» tiene un efecto más chico y menos seguro |
| Falso dominio | Acertar muchos ejercicios iguales hoy no quiere decir que se aprendió | Dos estados distintos: firme (le salió hoy) y dominado (le salió días después, mezclado y con un ejercicio parecido pero distinto) | Informe 5, temas 1 y 4 |
| Zona de desafío | Se aprende más cuando se acierta alrededor del 85 %: ni tan fácil que aburre ni tan difícil que frustra | Apunta a 80–85 % de aciertos en el trabajo nuevo; si baja del 70 %, facilita; si pasa del 95 %, sube la dificultad | Wilson, Shenhav, Straccia y Cohen (2019). Con reparo: es un modelo teórico, no una medición en un aula |
| Ejemplos resueltos para el que se traba | Al que recién empieza, o al que se trabó, le sirve más ver un ejemplo hecho que seguir intentando solo | El ejemplo resuelto es una de las formas de explicar; la lección muestra un calco del ejercicio con otros números, paso a paso. Si la hoja está en blanco no comenta lo escrito: ofrece seguir, practicar antes algo más simple o dejarlo para después | van Gog y Sweller (2015) |
| Idea | Qué dice, en simple | Qué hace la plataforma | De dónde sale |
|---|---|---|---|
| Hablar del proceso, no del resultado | La devolución que más enseña dice qué hizo, por qué está mal y cómo seguir. Decir solo «bien» o «mal» enseña poco | La devolución va en bloques fijos —Tu resolución, Lo que hiciste, Qué pasó y por qué, Cómo se hace—, las pistas señalan el renglón y las explicaciones apuntan a la causa | Hattie y Timperley (2007), cuatro niveles de devolución. Wisniewski, Zierer y Hattie (2020): la devolución con mucha información rinde unas cuatro veces más que un «¡bien!» |
| Enseñar a controlarse solo | El nivel más alto de devolución le enseña al chico a darse cuenta solo de sus errores | Consejos de control («reemplazá la x y fijate si da») y el trabajo sobre los hábitos que se le repiten | Hattie y Timperley (2007) |
| No elogiar a la persona | Decir «sos inteligente» no enseña nada y puede hacer que el chico evite lo difícil. Cambiarlo por «te esforzaste» tampoco alcanza | El progreso se cuenta en palabras de proceso; nunca «sos bueno» ni «sos malo», y sin elogios de relleno. Un control en código rechaza el elogio que no tenga un renglón correcto que lo respalde | Mueller y Dweck (1998); Kluger y DeNisi (1996): en más de un tercio de los casos la devolución empeoró el rendimiento cuando apuntaba a la persona |
| Sin nota mientras practica | Cuando hay nota, el chico mira la nota e ignora el comentario | No hay notas ni puntajes en ninguna pantalla del alumno | Butler (1988). Con reparo: es un estudio chico y viejo; se toma como regla práctica, no como ley |
| No dar la respuesta | Un tutor con IA que da las respuestas mejora la práctica pero empeora la prueba, porque el chico copia | Escalera de pistas que nunca llega al resultado; la IA no resuelve por él, y un filtro busca el resultado en todas sus formas antes de mostrar un texto | Bastani y colegas (Turquía, unos 1.000 alumnos): con un modelo sin límites, 17 % peor en la prueba sin IA; con pistas diseñadas, sin daño |
| Corregir cuando entendió algo mal | La devolución sirve cuando hay una idea equivocada para corregir; si no entendió nada, hay que enseñar desde el principio | Si no hay procedimiento escrito, no comenta lo escrito: ofrece las tres opciones, y la explicación del cierre trabaja la idea de fondo | Hattie y Timperley (2007) |
| Idea | Qué dice, en simple | Qué hace la plataforma | De dónde sale |
|---|---|---|---|
| Errores típicos | Muchos errores vienen de ideas equivocadas conocidas y repetidas, no del azar | El catálogo de errores de Eedi es la base de las listas de patrones y causas | Eedi Misconceptions Graph: 8.117 errores típicos y 2.258 pedacitos de matemática, con datos abiertos |
| Preguntas que separan causas | Una buena pregunta tiene opciones incorrectas que «hablan»: cada una delata una idea equivocada distinta | Las preguntas de causa tienen las opciones armadas para separar una causa de otra | Craig Barton y Eedi, preguntas diagnósticas |
| Comprobar que el error se fue | Para saber si un error desapareció hace falta un ejercicio que solo salga bien si el error ya no está | Ese tipo de ejercicio entra en los repasos 2 y 3 | Regla 5 de Barton |
| Seguridad al responder | Los errores dichos con seguridad se corrigen mejor, pero tienden a volver; un acierto «de casualidad» no es saber | Botones «Seguro», «Más o menos» y «Adiviné»; «Adiviné» cuenta como acierto asistido, y los errores dichos con seguridad entran en los repasos | Efecto de hipercorrección. Con reparo: en matemática no hay estudios fuertes; se mide |
Esta parte no es sobre cómo se aprende, sino sobre qué salió mal en los productos que ya existen. Importa tanto como lo anterior: el mejor método no sirve si el chico no aparece.
| Qué pasó afuera | Qué dice, en simple | Qué hace la plataforma | De dónde sale |
|---|---|---|---|
| El chico no aparece | El mayor problema de los tutores con IA es que los chicos los usan poco | Los adultos acompañan: se registra quién empieza cada sesión y hay avisos de repasos pendientes | Khanmigo: el alumno típico lo usó un tercio de los días. Varsity Tutors: solo el 15 % llegó a la práctica recomendada |
| Quedar atrapado | Si el sistema insiste sin salida, los que más les cuesta se frustran y abandonan | Dos oportunidades al cerrar y la opción «Hasta acá llegué»; el botón «Lo retomamos después» no tiene sanción; más adelante, cambiar la forma de explicar tras dos fallos | Ensayo de Eedi: los alumnos más flojos quedaron atrapados en el ciclo de diagnosticar y corregir |
| Que decida algo | Poder elegir algo mantiene las ganas | El alumno elige qué practicar —qué tarjeta tocar— y el orden de algunos ejercicios | Sin evidencia: es una hipótesis de diseño del proyecto, no un resultado de la investigación |
Cinco lugares donde la plataforma decide algo que la investigación no respalda del todo. Cada uno aparece también como aviso en su capítulo.
Que repasar días después funcione mejor está probado. Cuántos días, no: la investigación no da una fórmula única. Esos tres números son un punto de partida razonable, son parámetros que se cambian sin tocar el programa, y se calibran con lo que pase con el alumno.
Que las comprobaciones del repaso vayan sin ayuda se apoya en una idea muy citada: intentar acordarse fija más que releer. En matemática, sin embargo, el efecto probado es más chico y menos seguro que el de espaciar y mezclar. Se mantiene porque no hace daño y porque además deja ver qué sabe de verdad, no porque esté demostrado.
La «zona de desafío» —apuntar a que acierte entre el 80 y el 85 %— viene de un trabajo matemático sobre cómo aprenden las máquinas, no de una medición con chicos en un aula. La plataforma lo usa como punto de partida y mide si en la práctica sirve.
La idea de que un error dicho con seguridad se corrige mejor viene de otras materias. En matemática no hay estudios fuertes. Los tres botones están para medirlo, no porque se sepa que funciona.
No hay evidencia detrás: es una hipótesis de diseño. Se mantiene porque cuesta poco y porque el riesgo —que practique siempre lo mismo— lo cubre la plataforma, que es la que decide qué entra en la sesión.
El detalle de cada uno está en los informes del proyecto, sobre todo en el informe 5. Acá va de dónde sale cada afirmación del capítulo.
| Fuente | Qué aporta | Qué tan firme es |
|---|---|---|
| Murray, Horner y Göbel (2025) | Metaanálisis de 27 estudios de repaso espaciado en matemática | Firme: efecto robusto, específico de matemática |
| Rohrer y colegas (2020) | 787 alumnos de 7.º grado; práctica mezclada contra práctica en bloque; 61 % contra 38 % un mes después | Firme: ensayo grande, en matemática, con medición diferida |
| Hattie y Timperley (2007) | Los cuatro niveles de devolución: tarea, proceso, autocontrol y persona | Firme como marco; no es un experimento |
| Wisniewski, Zierer y Hattie (2020) | La devolución con mucha información rinde unas cuatro veces más que un «¡bien!» | Firme: metaanálisis |
| Mueller y Dweck (1998) | Elogiar la inteligencia hace que el chico evite lo difícil | Medio: muy citado, con réplicas desiguales |
| Kluger y DeNisi (1996) | En más de un tercio de los casos la devolución empeoró el rendimiento | Firme: metaanálisis clásico |
| van Gog y Sweller (2015) | El ejemplo resuelto le sirve más al que recién empieza o se trabó | Firme en tareas de procedimiento |
| Wilson, Shenhav, Straccia y Cohen (2019) | La «zona de desafío» alrededor del 85 % de aciertos | Flojo para esto: es un modelo teórico, no un aula |
| Butler (1988) | Con nota, el chico ignora el comentario | Flojo: estudio chico y viejo |
| Bastani y colegas | Unos 1.000 alumnos en Turquía: con un modelo sin límites, 17 % peor en la prueba sin IA | Firme para la decisión de no dar la respuesta |
| Craig Barton y Eedi | Preguntas diagnósticas y la regla 5 (comprobar que el error se fue) | Práctica profesional, no ensayo |
| Eedi Misconceptions Graph | 8.117 errores típicos y 2.258 pedacitos de matemática, con datos abiertos | Base de datos, no estudio |
| Khanmigo y Varsity Tutors | Cuánto se usaron en la práctica: un tercio de los días; 15 % llegó a la práctica recomendada | Datos de producto, no ensayo |
| Ensayo de Eedi | Los alumnos más flojos quedaron atrapados en el ciclo de diagnosticar y corregir | Ensayo, en matemática |
| Efecto de hipercorrección | Los errores dichos con seguridad se corrigen mejor pero vuelven | Flojo en matemática: no hay estudios fuertes |
Ninguna de estas ideas se da por cierta. Esto es lo que la plataforma observa para saber si en este caso funcionan.
Para entenderCapítulo 5 · Vigente al 16/11/2026
Hay 45 reglas escritas que no se negocian tarea por tarea. Están numeradas y guardadas en un archivo aparte, que el programa puede leer; y si un pedido choca con alguna, ese pedido no se aplica: se avisa qué se perdería y se espera una decisión.
No son buenas intenciones. Son la lista contra la que se revisa cada cambio.
Porque las cosas importantes se pierden de a poco. Nadie decide un día «mostremos textos sin revisar»: se decide, una vez, mostrar este texto sin revisar, porque hay apuro. Y después otro. Una lista fija convierte cada una de esas decisiones en algo que hay que discutir explícitamente.
Y porque esta plataforma la construye un equipo que cambia —chats distintos, revisores distintos, agentes distintos—. Lo que no está escrito, no se hereda.
La lista completa de las 45 está en ese archivo. Estas son las que explican la mayor parte de lo que hace la plataforma:
| Regla | Qué dice |
|---|---|
| Acertar hoy no es dominar | «Firme» es lo que salió hoy; «dominado», lo que volvió a salir días después, mezclado y en otro ejercicio |
| El tutor nunca da la respuesta | No la ve hasta que el ejercicio cierra, y un filtro en código rechaza todo mensaje que la contenga |
| Leer antes de diagnosticar | Con una lectura dudosa, primero se pregunta «¿escribiste esto?» |
| Un método distinto pero correcto se acepta | Se registra; nunca se marca como error |
| En matemática decide el programa | Hay un programa aparte que rehace cada cuenta con matemática exacta. Nada de lo que devuelve una IA se usa sin pasar por un control que no sea esa misma IA |
| Las reglas no se le piden a una IA | Cuánto sabe el alumno cada habilidad, por qué se equivocó, cuándo toca un repaso y cuándo algo queda bloqueado lo calcula el programa, no un modelo |
| Las IA no recuerdan nada | Cada consulta empieza de cero: lo que la IA necesita saber se lo arma el programa en ese momento leyendo la base. Lo que el alumno es está en la base, no en la memoria de un modelo |
| Nada sin controles | Ante la duda se suman controles; si sigue la duda, no se muestra. El costo nunca saca un control |
| Registro de todo | Con inicio, fin y quién. Nada se borra: se anula con motivo |
| Nada de lo que vio queda sin registro | Cada mensaje, con su texto exacto, su hora y su origen |
| Se observa antes de intervenir | No se lo interrumpe mientras trabaja; la ayuda llega cuando la pide |
| Insistir no es abandonar | Siempre hay una segunda oportunidad, y formas distintas de explicar cuando algo no entra |
| Siempre puede pausar | Sin sanción, en el lugar exacto, y se retoma |
| El perfil describe, no diagnostica | Solo hechos medibles. Una pausa no es una conclusión; un tiempo largo no baja nada |
| La devolución habla del procedimiento | Nunca de la persona. Sin elogios, emojis ni notas durante la práctica |
| Un alumno por tabla | Toda tabla lleva su identificador; la IA nunca mezcla alumnos |
| Datos solo a proveedores aprobados | Con una tabla de permisos que la puerta de la IA hace cumplir |
| Entre adultos no hay jerarquía | No existe la figura de «dueño»: los adultos a cargo de un alumno pueden lo mismo, topes de gasto incluidos. En lugar de pedirse permiso, queda rastro |
| Nadie valida matemática | Ninguna función espera que un adulto confirme una cuenta o una relación entre habilidades |
| Todo explicado por escrito | Fuera del código, actualizado en el mismo cambio, y una prueba falla si falta |
| Toda explicación dice cada paso | Completo y con su porqué, sin asumir nada. El audio dice todo lo escrito, incluido el igual |
| Es una prueba con un alumno | Sirve para decidir si seguir, no para afirmar que el método funciona en general |
Vale la pena mirarlas juntas, porque de a una parecen detalles y juntas son una postura:
No se aplica. Se avisa qué se perdería y se espera la decisión. No se busca una interpretación que lo permita, y no se aplica «solo por esta vez».
Lo que sí se puede cambiar son los números: los topes de gasto, los días de los repasos, los segundos de espera. Esos son valores configurables, con su historial, y están pensados para moverse. Una regla no es un número.
El camino de un ejercicioCapítulo 6 · Vigente al 16/11/2026
El tutor sube fotos de la hoja, o un PDF. La app separa la hoja en ejercicios sueltos, lee cada enunciado y lo resuelve por su cuenta para saber cuál es el resultado. Casi siempre sale bien; cuando no, el tutor tiene que poder arreglarlo sin salir de la pantalla.
Este capítulo recorre las tres pantallas: los datos de la tanda, subir la hoja, y revisar lo que el programa leyó. La tercera es la que más ocupa, porque es donde se arregla lo que salió mal, y termina con el portón que impide darle la tanda al alumno antes de haber mirado.
Un adulto entra a la aplicación y cae en su Inicio. Arriba de todas sus pantallas hay un menú con tres grupos —Práctica, Informes y Ajustes— y, al lado del nombre de la aplicación, el selector de alumno: todo lo que se ve y se carga es del alumno elegido. Cargar una tanda está en Práctica → Cargar tanda.
Cargar una tanda son tres pasos, y la pantalla los muestra arriba todo el tiempo:
Las tres pantallas de los tres pasos son las que cubre el bloque «Todos los casos» del final, botón por botón.
Mientras la app trabaja, cada ejercicio va pasando por estados. Al tutor le importan los tres del final:
Un ejercicio que no entró nunca se pierde en silencio. Aparece en la lista, arriba, con su recorte de la foto y el motivo.
Son doce acciones. Todas se hacen desde la misma lista, sin salir de la pantalla.
| Acción | Para qué | Qué pasa después |
|---|---|---|
| Corregir la lectura | La app leyó mal el enunciado | Se escribe cómo dice de verdad. La app lo verifica de nuevo, solo a ese ejercicio |
| Está bien leído | Confirmar que coincide con la hoja | Queda confirmado, con quién y cuándo |
| Deshacer | Se confirmó por error | Vuelve a quedar sin confirmar |
| Reintentar | Falló la inteligencia artificial, no la hoja | Se vuelve a intentar ese ejercicio solo. No duplica nada |
| Unir con el anterior | Un ejercicio quedó partido en dos | Se juntan y se vuelve a leer |
| Separar | Dos ejercicios quedaron pegados en uno | Se corta donde indique el tutor |
| No es un ejercicio | Entró un encabezado, un margen, una nota | Sale de la tanda, con ese motivo |
| Quitar | Es un ejercicio pero no va en esta tanda | Sale de la tanda. Hay motivos a elegir, o se escribe uno |
| Cambiar el número | La app numeró mal («3» en vez de «3.b») | Se corrige el número o el inciso |
| Cambiar de dónde salió | El origen quedó mal (libro, carpeta, prueba) | Se cambia por ejercicio, no por tanda |
| Subir la resolución | La app no pudo resolverlo sola | Se sube la resolución del docente o del libro, y la usa como referencia |
| Cambiar la resolución | Se asoció a la resolución equivocada | Se reasigna con un toque |
Y dos más sobre la tanda entera: archivarla, y armar otra tanda con los que quedaron afuera, para no perder lo que no entró.
Es la acción más importante, y la que más cuidado tiene.
Cuatro cosas pasan cuando el tutor escribe la lectura correcta:
Escritos a mano son casi iguales. Si la app duda, no elige: pregunta.
Muchas hojas tienen una consigna general arriba: «Resolvé aplicando propiedades», «Sin usar calculadora». No es un ejercicio, pero cambia cómo hay que resolver todos los de esa hoja.
La app la detecta, la guarda aparte y la muestra arriba del ejercicio cuando el alumno lo resuelve. El tutor puede corregirla o decir «No es una consigna».
Si dos ejercicios de la misma tanda quedaron idénticos, suele ser un error de separación: la misma foto entró dos veces. La app avisa y pregunta.
El número del ejercicio es el que después ve el alumno y el que aparece en todos los informes, así que tiene reglas propias: va del 1 al 99, «01» es lo mismo que «1», y las mayúsculas y minúsculas del inciso dan igual («3.B» es «3.b»).
Cuando la lista está como el tutor quiere, falta un paso: mirar cada ejercicio y tocar «👍 Está bien leído».
Por qué este paso existe: la app lee de una foto, y cuando lee mal el error no se nota. El ejercicio entra, se ve prolijo, y el problema aparece recién cuando el alumno lo resuelve bien y la corrección se lo marca mal. Este es el único momento en que alguien compara la hoja con lo que entendió la app.
Nunca se le pide al tutor que resuelva un ejercicio ni que corrija matemática. Se le pide una sola cosa, la única que él puede hacer y la app no: mirar la hoja y decir si dice eso.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto: en qué situación aparece cada botón, qué hace y qué pasa después. Cubre los 44 botones y campos de las tres pantallas de los tres pasos.
Ese botón aparece solo cuando el problema fue la lectura y no la matemática: la hoja estaba cortada, falló la inteligencia artificial que lee, el renglón tenía una duda, la cuenta se podía leer de dos maneras, la doble lectura dio distinto, el enunciado no se pudo leer como cuenta, o quedó una duda sin resolver. Con cualquier otro motivo, el botón no está.
El camino de un ejercicioCapítulo 7 · Vigente al 16/11/2026
El alumno entra y ve tarjetas: lo que puede retomar, lo nuevo y lo que ya terminó. Toca una y empieza. No elige cuántos ejercicios ni cuánto tiempo: eso lo decide la app, mirando lo que le toca y cuánto suele tardar.
Esa simplicidad es deliberada. Pedirle a un chico que configure su propia sesión es pedirle que decida algo que no puede evaluar, y es una excusa más para no empezar.
Cada tarjeta trae cuatro números, y los cuatro están dichos en positivo. Ninguno es una nota ni un porcentaje de acierto:
| Número | Qué cuenta |
|---|---|
| Listos | Los que resolvió y le salieron bien |
| A medias | Los que empezó y no terminó. Se retoman donde quedaron |
| Sin hacer | Los que todavía no abrió |
| Lo vimos juntos | Los que no le salieron y la plataforma le explicó. No son un error anotado: son los que ya trabajaron los dos |
Notas, cronómetro, informes, su perfil de habilidades, los costos y la configuración. No es que estén escondidos: es que esas pantallas no existen para él. Lo que ve es qué practicar y cómo le fue en lo que hizo.
La sesión se arma mezclando tres cosas, en este orden de prioridad:
Dentro de eso, el orden lo decide el perfil de habilidades: qué conviene que practique ahora según lo que sabe y lo que falló.
La app no corta un ejercicio a la mitad. Cuando el tiempo estimado de la sesión se agota, le ofrece cerrar, no lo cierra. Y si está en medio de un ejercicio, hay un margen para terminarlo; si no llega, ese ejercicio queda pausado, sin ninguna sanción, y lo retoma otro día.
Hay además un tope de seguridad, para que una sesión no se estire sin fin: pasado cierto tiempo, la app ofrece cerrar. Nunca corta sola.
Esta es una decisión de diseño que cambia mucho la experiencia. Cuando el tutor carga una tanda, la app no espera a que el alumno abra un ejercicio para armar sus materiales: los prepara en ese momento, de fondo.
Se prepara y se guarda todo lo que no depende de lo que el alumno escriba: el pizarrón de su ejercicio, los ejercicios parecidos, las pistas, el ejemplo resuelto. Cada uno con los mismos controles que si se armara en el momento.
| Sin preparar de antemano | Preparado |
|---|---|
| El alumno pide una pista y espera a que se arme y se controle | La pista ya está guardada: aparece al instante |
| Si en ese momento falla un modelo, se queda sin pista | Si falló al prepararla, hubo tiempo de reintentar antes |
| El costo se paga mientras él espera | El costo se paga cuando no hay nadie esperando |
El tutor tampoco espera: la tanda dice «Preparando…» y él puede irse. Lo importante es la otra cara de esta regla, que está en su propio capítulo: preparar una tanda no puede trabar al alumno.
Esta parte no se lee de corrido. Cubre los estados de las tarjetas, los parámetros de la sesión y qué se prepara de antemano.
| Tarjeta | Cuándo aparece | Qué hace al tocarla |
|---|---|---|
| Para retomar | Hay una sesión pausada o un ejercicio a medias | Retoma desde donde quedó |
| Nuevo | Hay una tanda dada y sin empezar | Empieza la sesión |
| Ya empezada | La tanda está empezada pero no en curso | Sigue con lo que falta |
| Terminadas | Siempre, en su propia pantalla | Muestra lo que ya hizo |
| Preparando… | La tanda se está preparando de fondo | Todavía no se puede empezar |
Listos, a medias, sin hacer y «lo vimos juntos», como están explicados arriba. Los adultos ven los mismos ejercicios contados de una manera algo distinta en «Tandas abiertas» —ahí hay cinco números, porque separan «no salió y se cerró» de los demás—, pero salen del mismo lugar: no hay dos contabilidades, hay un corte más fino para el adulto.
| Parámetro | Para qué sirve |
|---|---|
| Tope de seguridad al armar por cantidad | A partir de cuánto tiempo la app ofrece cerrar la sesión. Es un múltiplo del tiempo estimado |
| Tope de seguridad sin estimación | Lo mismo, en minutos, cuando todavía no hay datos de cuánto tarda ese alumno. Sirve en las primeras sesiones |
| Margen para terminar el ejercicio en curso | Tiempo extra para no cortar un ejercicio a la mitad. Si se agota, queda pausado sin sanción |
Los tres se pueden cambiar en cuatro niveles: para todo el sistema, para una sesión, para una tanda o para un alumno. Lo mismo vale para los otros 98 parámetros de la plataforma.
| Cuándo | Qué se prepara |
|---|---|
| Al cargar una tanda, apenas termina cada ejercicio | Todo lo que no depende de lo que escriba el alumno |
| Al generar un ejercicio nuevo | Lo mismo: vale para parecidos, contrastes, prácticas y repasos |
Concretamente: el pizarrón de «Ver cómo se resuelve este ejercicio», armado por el programa y comprobado renglón por renglón; los ejercicios parecidos; las pistas de los escalones de ayuda; el ejemplo resuelto. Todo con sus controles, guardado y listo.
Nada que dependa de lo que el alumno escriba: la corrección de sus renglones, la devolución de su error, la parte de «en tu ejercicio» de un consejo. Eso solo existe cuando él ya escribió.
El camino de un ejercicioCapítulo 8 · Vigente al 16/11/2026
Dos cosas que parecen distintas y son la misma: que lo practicado no se olvide, y que una interrupción no arruine el trabajo. Las dos tratan sobre el tiempo.
Los repasos traen de vuelta lo que ya hizo, en fechas calculadas. Las pausas se ocupan de que irse en medio de un ejercicio —porque sonó el timbre, porque se cortó internet, porque se distrajo— no tenga costo.
Cuando el alumno termina todos los ejercicios de una tanda, la app arma el Repaso 1 para unos días después. Por defecto, los repasos van encadenados a los 2, 5 y 14 días; también se pueden poner fechas fijas.
Que repasar días después funcione mejor que practicar todo junto está probado en matemática. Cuántos días, no: no hay una fórmula única. Los tres números son un punto de partida, son parámetros que se cambian sin tocar el programa —en «Valores por defecto» o en cada tanda— y se calibran con lo que pase con el alumno. En En qué se apoya está de dónde sale cada cosa.
Lo mismo con que las comprobaciones vayan sin ayuda: la idea de que intentar acordarse fija más que releer está muy citada, pero en matemática el efecto probado es más chico y menos seguro que el de espaciar y mezclar.
Cada repaso trae dos clases de ejercicios, y la diferencia importa:
No se da por perdida ni se repite al día siguiente. Hay una vuelta nueva dos días después, solo con lo que falló, y con ejercicios equivalentes nuevos, no los mismos.
Eso puede pasar hasta tres veces. A la tercera vuelta fallada no hay una cuarta: el repaso queda completo, con esos temas anotados como pendientes. Insistir una cuarta vez no enseña; lo que hace falta ahí es otra cosa, y los tutores tienen que enterarse.
El Repaso 2 no se puede hacer antes de completar el 1. Con fechas fijas, si llega la fecha del 2 y el 1 sigue abierto, el 2 queda bloqueado y se anotan los días que pasaron. Un repaso sirve porque viene después de otro: hacerlos en desorden no es lo mismo.
El día que toca un repaso le llega un recordatorio al alumno y a quien corresponda. Al final del día, si no lo hizo, el aviso va a los adultos. No se le insiste a él dos veces: se le avisa a quien puede hacer algo.
La pantalla del alumno manda una señal de «sigo acá». A partir de eso, la app distingue entre un parpadeo y una ida de verdad:
| Qué pasa | Qué hace la app |
|---|---|
| Sin señal por 2 minutos | Se considera un corte |
| Vuelve dentro de los 5 minutos siguientes | Fue un microcorte: sigue como si nada |
| No vuelve | La sesión pasa a Pausados, como «sin conexión», y se avisa |
| Está conectado pero 10 minutos sin actividad | Una pregunta suave: ¿cómo vas? |
| 20 minutos sin actividad | La sesión pasa a Pausados |
Ni el de un corte. El tiempo activo de una sesión es el tiempo en que el alumno estuvo trabajando, no el que pasó desde que empezó. Si no fuera así, los números de «cuánto tarda» serían inservibles y además lo castigarían por haber ido a cenar.
Son fijos, salen del catálogo y tienen dos reglas: sin culpa y sin nombrar a los tutores. «Tu trabajo queda guardado y seguimos en un rato» no es lo mismo que «te fuiste» ni que «le avisamos a tu papá».
Al volver, retoma donde quedó: el ejercicio, los renglones ya confirmados, la foto si la había subido. Nada se pierde entre sesiones.
Si la sesión se había pausado por una falla del sistema —no por él—, al retomarla se reintenta sola una vez, antes de molestarlo con nada.
Esta parte no se lee de corrido. Cubre los valores exactos, los estados de un repaso y cada tipo de interrupción.
| Qué | Valor por defecto |
|---|---|
| Sin señal para considerar un corte | 2 minutos |
| Ventana para que sea solo un microcorte | 5 minutos más |
| Sin actividad para la pregunta suave | 10 minutos |
| Sin actividad para pasar a Pausados | 20 minutos |
| Días encadenados de los repasos | 2, 5 y 14 |
| Días hasta la vuelta nueva de una comprobación fallada | 2 |
| Vueltas máximas de un repaso | 3 |
Todos son parámetros configurables, no números fijos del programa. Se pueden cambiar para el sistema, para una sesión, para una tanda o para un alumno.
| Estado | Qué quiere decir |
|---|---|
| Programado | Tiene fecha y todavía no llegó |
| Disponible | Llegó el día y se puede hacer |
| Bloqueado | Llegó la fecha pero el repaso anterior sigue abierto. Se anotan los días que pasaron |
| En vuelta nueva | Algo falló y vuelve en dos días, solo con lo que falló |
| Completo | Se hizo entero |
| Completo con pendientes | Se agotaron las tres vueltas y quedaron temas sin salir |
| Tipo | De dónde sale | Con ayuda |
|---|---|---|
| Comprobación | Parecidos de lo que salió bien | No |
| Calentamiento | Primero de los de recuperación, más accesible | Sí |
| Recuperación | Equivalentes de lo que no salió | Sí |
Las comprobaciones cubren todas las habilidades de la tanda, no una muestra. Si una habilidad no tiene con qué comprobarse, eso se anota.
| Interrupción | Qué registra | Qué ve el alumno |
|---|---|---|
| Microcorte | Queda anotado, no pausa nada | Nada |
| Sin conexión | Pausado, con el motivo | Un texto fijo, sin culpa, al volver |
| Inactividad | Pregunta: «Estoy pensando», «Me trabé», «Me distraje» | La pregunta suave |
| Pausa a mano | Pausado, pedido por él | «Lo retomamos después» |
| Falla del sistema | Pausado, con el motivo técnico | Un texto fijo; al volver se reintenta solo una vez |
Solo quien está en la lista de accesos, con el mail confirmado por Google. Cada intento queda registrado, también los que no entraron: eso es lo que después se ve en la pantalla de Accesos de los tutores.
El camino de un ejercicioCapítulo 9 · Vigente al 16/11/2026
El alumno resuelve en papel, como lo haría siempre. Cuando termina, le saca una foto a la hoja. La app lee los renglones escritos a mano y antes de corregir nada le muestra lo que entendió, para que él confirme o lo arregle.
Ese paso intermedio es el corazón del módulo. Sin él, la app corregiría contra algo que el alumno no escribió, y le marcaría errores que no cometió.
| Paso | Qué pasa |
|---|---|
| 1 · Se sube | Desde el celular o desde la computadora, con una de tres opciones: «Ejercicio completo», «Hasta acá llegué» o «En proceso» |
| 2 · Se lee | Entra en la cola de trabajos. Un modelo lee la hoja y devuelve los renglones como texto |
| 3 · Segunda mirada | Si un renglón quedó dudoso, lo mira un segundo modelo. Si el permiso está encendido, uno de otra empresa, sin mandar quién es el alumno |
| 4 · Se confirma | Siempre se le muestra lo leído y se le pregunta «¿Escribiste esto?». Recién con su respuesta se evalúa |
| 5 · Se corrige | Pasa al módulo de la corrección, con los renglones tal como él los confirmó |
Si pasan 30 segundos sin respuesta, la app le avisa que está trabajando. Nunca le muestra un resultado a medias, y nunca le dice qué modelo está usando.
El alumno trabaja en la computadora pero la foto la saca con el celular. Para unirlos, la computadora muestra un código QR: el celular lo escanea y queda emparejado con ese alumno.
Acá la app muestra, renglón por renglón, lo que entendió de la foto. El alumno tiene dos caminos: confirmar todo, o arreglar lo que esté mal.
| Forma | Cuándo conviene |
|---|---|
| 📷 Le saco una foto solo a este renglón | La más fácil, y la que la app ofrece primero. La computadora pide la foto de ese renglón y el celular pasa a sacarla |
| ⌨️ Lo escribo acá | Lo escribe en la computadora. Mientras escribe, ve cómo queda dibujado, para saber si la app lo está entendiendo |
| 🗑️ Este renglón no lo escribí | El renglón lo armó la lectura, no él. Lo saca de lo leído, y tiene «Deshacer» |
| 📷 Leí mal casi todo | Otra foto de toda la hoja. La foto nueva reemplaza a la anterior recién cuando llega |
Un chico tacha todo el tiempo: se equivoca, tacha y sigue. La app separa lo tachado de lo que vale, y lo que evalúa es lo que quedó.
Pero hay un caso que parece tachado y no lo es: cuando el tachón deja medio número. En ~~9~~3/1 el alumno no se equivocó: simplificó, tachó el 9 y escribió el 3. Eso no es un error, es una simplificación, y la app lo trata como tal.
Y una regla que viene de la corrección: una marca de tachado nunca borra un error. Si el renglón tachado tenía un error y el alumno no volvió a hacerlo bien, el error sigue abierto.
Cuando alguien simplifica, escribe números chiquitos arriba y abajo de la cuenta. La lectura a veces los junta y arma con ellos un renglón que el alumno nunca escribió.
La app detecta ese caso y, en vez de corregir un renglón inventado, pregunta:
Si una foto se anula, deja de leerse, deja de evaluarse y no cuenta para nada. Pero el archivo queda, y queda anotado quién la anuló y cuándo. Es la regla general del registro: se agrega, no se pisa.
Esta parte no se lee de corrido. Cubre los 45 botones y opciones que tiene el módulo, los límites de las fotos y qué pasa en cada situación.
| Botón | Qué hace |
|---|---|
| Sacar foto | Saca la foto de la hoja completa |
| 📷 Sacar foto del renglón | Aparece cuando la computadora pidió la foto de un renglón suelto |
| Sacar otra | Descarta la que sacó y vuelve a la cámara |
| Subirla igual | Aparece cuando la foto salió un poco movida. Si está muy movida, no hay «subirla igual»: hay que sacar otra |
| Mandar de nuevo | Aparece si falló el envío. Reintenta sin volver a sacarla |
| Anular foto | Anula la foto subida. El archivo queda guardado |
| 💻 Seguir en la PC / Lo confirmo en la PC | Pasa el control a la computadora. La hoja leída no se revisa en el celular: es difícil de ver |
| Ejercicio de hoy | Muestra a qué ejercicio va la foto, cuando la computadora cambió de ejercicio mientras sacaba la foto |
| Botón | Qué hace |
|---|---|
| 📱 Sacar la foto con el celular | Muestra el QR y, debajo, el enlace escrito |
| Subir desde esta PC | Abre los archivos de la computadora |
| Pedir otro QR | Genera uno nuevo cuando el anterior venció |
| Cerrar / Cancelar | Cierran el panel sin subir nada |
| Botón | Qué hace |
|---|---|
| 👍 Sí, es así | Confirma todo lo leído y arranca la corrección |
| ✏️ No, hay algo distinto / ✏️ No es así | Abre las formas de arreglar |
| Guardar cambios | Guarda lo corregido y verifica |
| Cancelar / Cerrar | Vuelve sin cambiar nada |
| ? | Abre la ayuda, debajo del dato |
| Botón | Qué hace |
|---|---|
| 📷 Le saco una foto solo a este renglón | La computadora pasa a «Sacale una foto solo al renglón N» y el celular emparejado, a «Foto del renglón N», sin las tres opciones. Esa foto no cuenta como foto del ejercicio: queda atada al renglón que reemplaza |
| ← Volver a lo que leí | Cancela la foto del renglón y vuelve a la lectura anterior |
| Mejor lo escribo acá / ⌨️ Lo escribo acá | Abre el editor, con el dibujo en vivo de «Así queda» |
| Mejor le saco una foto | El camino inverso: del editor a la foto |
| Guardar el renglón | Guarda lo que escribió y vuelve a la lista de renglones |
| Cambiar | Vuelve a abrir una respuesta que ya había dado |
| 🗑️ Este renglón no lo escribí | Lo saca de lo leído. Nada de lo que escribió se pierde |
| Deshacer | El renglón vuelve igual que estaba |
| 📷 Leí mal casi todo: otra foto de toda la hoja | Vuelve a la cámara con las tres opciones. La foto nueva reemplaza a la que estaba por confirmar recién cuando llega |
| Pregunta | Respuestas | Qué pasa con cada una |
|---|---|---|
| Un número suelto | «Lo escribí como un paso» / «Lo anoté al costado» | Como paso: se corrige como un renglón más. Al costado: se ignora y el ejercicio puede cerrar bien |
| ¿Este renglón lo escribiste? (parece armado con numeritos) | Sí / No | Si dice que no, el renglón sale de lo leído y no se corrige |
| ¿Hay un punto o una coma? | «3 por 4» / «3 coma 4» | Se queda con la lectura que él eligió y se verifica con esa |
| Límite | Valor | Qué pasa si se pasa |
|---|---|---|
| Tamaño del archivo | 12 MB | No se guarda |
| Píxeles de la imagen | 40 millones | Ni siquiera se abre, para que no cuelgue el servidor |
| Lado largo al que se achica | 1.568 px | Más grande no se lee mejor. Se achica en el aparato y otra vez en el servidor |
| Calidad del JPEG | 85 | — |
| Nitidez mínima | un parámetro configurable | Por debajo, no se sube: hay que sacar otra |
| Nitidez dudosa | otro parámetro, más alto | Entre los dos, avisa y deja «Subirla igual» |
| Caso | Qué hace la app |
|---|---|
| La computadora cambió de ejercicio mientras sacaba la foto | Pregunta a cuál de los dos va la foto |
Un tachón que deja medio número (~~9~~3/1) | Lo toma como una simplificación, no como un error |
| Un renglón repetido (lo reescribió más claro) | Se toma como el mismo renglón; vale el de abajo, que es el más nuevo |
| La sesión se cortó por una falla | Al retomarla, se reintenta una vez sola, y el trabajo del alumno queda guardado |
| Una foto anulada | No se lee, no se evalúa, no cuenta, y el archivo no se borra |
| Un renglón dudoso | Segunda mirada de otro modelo. Si el permiso de usar un proveedor externo está apagado, la hace otro modelo de la misma empresa, y entonces no cuenta como mirada independiente |
El camino de un ejercicioCapítulo 10 · Vigente al 16/11/2026
La inteligencia artificial que mira la foto devuelve cada renglón como texto: (-2)^-3 : 1/4. Ese texto hay que convertirlo en una cuenta de verdad para poder comprobarla. Traducirlo mal es peor que no leerlo: la app corregiría contra algo que el alumno nunca escribió.
Por eso la traducción tiene dos reglas de oro, y la segunda es la importante:
En la escuela, con una fracción después significa dividir por toda la fracción:
Una calculadora leería y daría . Ese era el resultado equivocado que apareció en el ejercicio 5 de la primera prueba con una hoja de verdad.
Al revés que en inglés. 2.3 es , y 0,2 · 2,5 son decimales.
Con una excepción: el punto de los miles. Un punto con exactamente tres cifras después, y una a tres antes, es un separador de miles: 1.000 es mil y 12.500 es doce mil quinientos. Eso no se pregunta.
Nunca se usan decimales aproximados, porque arrastran error y después una comparación da mal por redondeo:
El arco o la rayita del período solo valen sobre un decimal. Si el número está escrito con punto y trae la marca de período, la app sabe que ese punto era una coma.
Se entiende escrita de las cinco formas en que la escriben los chicos:
| Escrito | Se lee |
|---|---|
2(3+1) | 2 por el paréntesis |
(a)(b) | uno por el otro |
3 x 4 | 3 por 4 |
3√2 | 3 por raíz de 2 |
3/4 de 8 | tres cuartos por 8 |
La letra x tiene dos vidas en una hoja de matemática, y confundirlas rompe todo:
3 x 4 es una multiplicación, no una ecuación con incógnita.2x = 5 es una ecuación, y se resuelve como tal.Y una distinción más fina, para saber si un renglón es una ecuación de verdad:
Superíndices (2⁻¹), raíces de cualquier índice (√, ∛, «raíz cúbica de»), corchetes y llaves, el valor absoluto —las dos barras verticales—, los porcentajes, y hasta el código LaTeX que a veces devuelve la inteligencia artificial que lee la foto.
Estos son todos los casos en que una cuenta se puede leer de dos maneras con resultados distintos. En cada uno, la app guarda las dos lecturas y pregunta.
| Lo que está escrito | Las dos lecturas |
|---|---|
6 : 2(1+2) | Después de dividir hay una multiplicación sin signo: ¿divide por el 2 o por todo? |
√x² | ¿La potencia va adentro o afuera de la raíz? |
√16/100 | ¿Hasta dónde llega la raíz? |
2^3^2 | Una potencia de una potencia sin paréntesis |
1 1/2 | Un entero pegado a una fracción: ¿número mixto o multiplicación? |
2·4/9·4 | Una multiplicación arriba y abajo de una barra: ¿qué abarca la raya? |
0.5 | Un punto después de un cero: parece un decimal escrito con punto |
Y hay un detalle importante: si las dos lecturas dan el mismo valor, no hay duda y la app sigue sin preguntar nada. Solo molesta cuando la diferencia cambia el resultado.
Distinto de no entenderla: acá se entiende perfecto, pero el resultado no existe. Son tres casos, y cada uno se avisa como lo que es:
Una hoja mal leída puede generar una cuenta imposible de calcular. Cuatro topes la frenan antes:
| Tope | Valor | Por qué |
|---|---|---|
| Dígitos de un número | 40 | Un número más largo es casi seguro un error de lectura |
| Exponente | 200 | |
| Tamaño del resultado | 20.000 bits | Unas 6.000 cifras. Ninguna cuenta de secundaria llega ni cerca |
| Tiempo de cálculo | 2 segundos | Si tarda más, el renglón queda «no se pudo comprobar» y el servidor sigue atendiendo |
Cuando un tope frena una cuenta, el renglón no queda mal: queda sin comprobar, y se dice por qué.
Al leer un renglón, la app termina siempre en una de tres: lo entendí (y acá está el valor exacto), se puede leer de dos maneras (y estas son), o no lo entiendo. Nunca en una cuarta, que sería la peligrosa: «elegí una de las dos y seguí».
Esta parte no se lee de corrido. Cubre qué ve el alumno cuando la lectura hay que arreglarla, y qué hace cada botón.
El camino de un ejercicioCapítulo 11 · Vigente al 16/11/2026
Corregir no es mirar si el resultado final está bien. Es recorrer la hoja de arriba abajo y comprobar una sola cosa en cada renglón: que valga lo mismo que el de arriba. Si cada paso vale lo mismo que el anterior y el último es el resultado, la resolución está bien.
Y una regla que ordena todo el módulo: la corrección la decide el programa, nunca la inteligencia artificial. El modelo que lee la foto puede opinar que un renglón está bien o mal; esa opinión no se usa. Se usa la cuenta.
Ejercicio 5.a. El alumno escribió esto:
El renglón 2 vale lo mismo que el enunciado: ✓. El 3 no vale lo mismo que el 2, porque
Esa distinción importa mucho. Si el renglón 4 se marcara ✗, el alumno pensaría que cometió dos errores cuando cometió uno solo, y la app diría que no sabe hacer algo que sí sabe.
Una hoja no es solo la cadena de pasos. Al margen hay cuentas sueltas: una suma auxiliar, una simplificación, un «100x − x» para pasar un periódico a fracción. Esas cuentas no son parte de la cadena y no se comparan con el renglón de arriba: se comprueban solas.
Pero no se ignoran. El programa mira si la cuenta al costado está bien, y sobre todo si la cadena usa su resultado:
| La cuenta al costado… | Qué pasa |
|---|---|
| está bien | ✓, fuera de la cadena. No afecta nada |
| está mal y la cuenta la usa | ✗ en el renglón de la cuenta al costado, y el renglón que usa ese valor queda «sigue» |
| está mal y la cuenta no la usa | Ni ✓ ni ✗: queda pendiente de una pregunta, y el ejercicio no cierra bien |
| no se puede comprobar | Queda anotada como anotación sin comprobar |
Un alumno que se equivoca y después vuelve a empezar bien no cometió un error que haya que arrastrar hasta el final. Pero para que eso valga, el arreglo tiene que ser real. El programa exige tres cosas de un renglón para aceptarlo como reinicio:
Si las tres se cumplen, el error queda cerrado y el ejercicio cierra como «bien, se corrigió solo». Si no, el error sigue abierto por más que el resultado final dé bien.
El modelo que lee la foto a veces marca un renglón como «se corrigió solo». Esa marca se borra siempre y la vuelve a decidir el programa con las tres condiciones de arriba. Cuando el modelo decía que sí y el programa no lo confirma, queda anotado: sirve para medir cuánto se equivoca el modelo.
El caso más difícil de detectar, y el que más daño hace si pasa. El renglón vale lo correcto, pero llegó ahí por dos errores que se anularon entre sí:
El resultado de los dos renglones es 4, así que una comparación de valores diría ✓. Pero el 8 no sale de ninguno de los términos de arriba, y el 4 tampoco. El programa compara término por término, no solo el valor total, y lo marca ✗.
Hay tres situaciones en las que el programa tiene la cuenta pero no puede marcar sin adivinar. En las tres, en vez de elegir, le pregunta al alumno.
Esta parte no se lee de corrido. Está para saber exactamente por qué un renglón quedó como quedó. Cada decisión deja guardado su motivo, y es uno de estos textos.
El programa recorre la hoja en cuatro pasadas, siempre en este orden:
| Pasada | Qué hace |
|---|---|
| 1 · Limpiar | Borra la marca de «se corrigió solo» que haya puesto la inteligencia artificial, y deja todos los renglones dentro de la cadena hasta que se demuestre lo contrario |
| 2 · Apartar las cuentas al costado | Saca de la cadena lo que es una cuenta al margen, y decide cada una por su cuenta |
| 3 · Recorrer la cadena | Renglón por renglón, comparando cada uno con el de arriba |
| 4 · Propagar | Los renglones tachados con un error y los «sigue» de un error que después se corrigió quedan al día |
| Caso | Marca | Motivo que queda guardado |
|---|---|---|
| Cuenta del periódico que da | ✓ | cuenta del periódico comprobada |
| Cuenta del periódico que no da | ✗ | cuenta del periódico que no da |
| Renglón que usa un valor del periódico que no dio | sigue | usa el valor de una cuenta del periódico que no dio |
| Número suelto que vale una parte del renglón de arriba | ✓ | número suelto que vale una parte del renglón de arriba |
| Cuenta al costado con sus dos lados iguales | ✓ | cuenta al costado comprobada por el programa |
| Cuenta al costado falsa que la cadena no usa | sin comprobar | cuenta al costado falsa (comprobada por el programa) |
| Cuenta al costado falsa que la cadena sí usa | ✗ | cuenta al costado falsa que la cuenta usa |
| Anotación al margen que no se puede comprobar | sin comprobar | anotación al costado que no se puede comprobar |
| Anotación que sale del renglón anterior | aparte | anotación que sale del renglón anterior |
| Caso | Marca | Motivo |
|---|---|---|
| Vale lo mismo que el enunciado | ✓ | el primer renglón sale del enunciado |
| No vale lo mismo que el enunciado | ✗ | el primer renglón no sale del enunciado |
| El enunciado no se puede leer como cuenta | según lo que valga | primer renglón: vale lo del ejercicio |
| No se puede comprobar nada | sin comprobar | no se pudo comprobar |
| Caso | Marca | Motivo |
|---|---|---|
| Vale lo mismo que el de arriba | ✓ | sale del renglón anterior |
| No vale lo mismo | ✗ | no sale del renglón anterior |
| Vale lo del ejercicio pero no se pudo comparar con el de arriba | ✓ | no se pudo comprobar que salga del anterior |
| Los términos no cierran y hay una compensación | ✗ | dos errores que se compensan |
| Nada comprobable | sin comprobar | no se pudo comprobar |
Es la parte más fina del módulo: acá se decide si el alumno arrastró el error o lo arregló.
| Caso | Marca | Motivo |
|---|---|---|
| Sigue correctamente desde el renglón malo | sigue | sigue de un renglón mal |
| Rehace las cuentas desde un renglón bueno anterior | ✓ y cierra el error | reinicio de verdad: rehace las cuentas de un renglón bien |
| Vale lo del ejercicio, pero un término no sale de ninguno | ✗ | vale lo del ejercicio, pero un término no sale de ninguno (dos errores que se compensan) |
| Vale lo del ejercicio pero no sale de lo que venía haciendo | ✓, y el error de arriba sigue abierto | vale lo del ejercicio pero no sale de lo que venía haciendo |
| No sale del de arriba ni vale lo del ejercicio | ✗ | no sale del renglón anterior |
La cuarta fila es una decisión explícita: el renglón recibe su ✓ porque lo que escribió vale, pero el ejercicio no cierra como bien, porque el error anterior nunca se arregló.
| Caso | Marca | Motivo |
|---|---|---|
| Vale lo del ejercicio | ✓ | vale lo del ejercicio |
| No vale lo del ejercicio | ✗ | no vale lo del ejercicio |
| La IA lo marcó mal y el programa no puede comprobarlo | ✗ | la IA lo marcó mal y el programa no lo puede comprobar |
| Nada comprobable | sin comprobar | no se pudo comprobar |
Esa tercera fila es la única situación en que la opinión del modelo cambia algo, y solo en la dirección prudente: puede marcar mal, nunca bien.
Un renglón tachado entero se evalúa igual: la marca de tachado no lo saca de la cadena, porque esa marca puede venir del modelo que lee la foto y una marca no puede borrar un error.
| Caso | Qué queda |
|---|---|
| Tachado, con un error, y después lo rehízo | Sin marca, fuera de la cadena, pero anotado: el cierre es «bien, se corrigió solo», nunca «bien» a secas |
| Tachado, con un error, y no lo rehízo | Sin marca tampoco, pero el error sigue abierto y el ejercicio no cierra bien |
| Caso | Qué hace el programa |
|---|---|
| El renglón se puede leer de dos maneras con valores distintos | Sin marca, y se le pregunta al alumno cómo lo quiso decir |
Número mixto (1 1/2) | No pregunta: se queda con la lectura que sale del renglón anterior. Si ninguna sale, y el modelo lo marcó mal, queda ✗ |
| Un número suelto que quedó aparte | No corta la cadena: el renglón siguiente se compara con el último renglón de la cadena, no con el número suelto |
| Un renglón con palabras («da como resultado 5/7») | Se evalúa con la cuenta que contiene. Si no tiene ninguna cuenta en números, queda sin comprobar |
| Una cuenta al costado verdadera de una parte del renglón de arriba | ✓ y fuera de la cadena; el renglón siguiente se compara con el de arriba, salteándola |
El camino de un ejercicioCapítulo 12 · Vigente al 16/11/2026
El control único es un chequeo que corre justo antes de guardar la corrección de un ejercicio, y otra vez antes de cerrarlo. Revisa que no haya quedado ningún renglón con un visto bueno que nadie comprobó, y que el ejercicio no cierre como «bien» si todavía hay algo sin resolver.
El alumno nunca lo ve. Es un control de la app sobre sí misma.
Un error que recibe ✓ es el peor resultado que puede dar la plataforma: el alumno se lleva la idea de que lo hizo bien, y la app además guarda esa habilidad como dominada. Después le va a dar ejercicios más difíciles apoyados en algo que en realidad no sabe.
Antes había varios caminos por los que eso podía pasar: un renglón que la app no pudo leer y quedaba sin marca, un número al costado que nadie sabía si era parte de la cuenta, un error que el alumno arrastraba y después tachaba a medias. Cada uno se arreglaba por separado. El control único los cierra todos de una vez, con una regla simple: si no está comprobado, no pasa.
| Motivo | Qué quiere decir |
|---|---|
| Hay un ✓ sin comprobar | Un renglón quedó bien marcado sin que el programa hiciera la cuenta |
| Un renglón sin marca | Quedó un renglón sin ✓, sin ✗ y sin un motivo que lo explique |
| Un error sin arreglar | Hay un renglón mal comprobado y el alumno no volvió a empezar desde ahí |
| Falta el resultado | El último renglón no es el resultado que el programa calculó |
| Un paso sin comprobar | Quedó un renglón que no se pudo comprobar, o una duda que el alumno no contestó |
| Escribió solo el resultado | Está el resultado correcto pero no están los pasos |
| No se puede leer el enunciado | El programa no logra leer el enunciado como una cuenta, así que no tiene contra qué comparar |
El control está hecho para no castigar lo que en realidad está bien:
El control en sí no tiene pantalla, pero sí la tiene lo que provoca: cuando algo queda sin comprobar, en vez de adivinar, la app le pregunta al alumno.
Ante la duda, la app no marca bien ni marca mal: deja el renglón sin comprobar, no cierra el ejercicio como «bien» y pregunta. Equivocarse diciendo «está bien» es mucho más caro que preguntar de más.
Esta parte no se lee de corrido. Son las situaciones que el control único decide, una por una.
En matemática la marca siempre la pone el programa: rehace la cuenta y decide. Pero la IA que leyó la hoja también opina si el renglón está bien, y esa opinión se guarda al lado para poder compararlas. Cuando coinciden —que es lo normal— no pasa nada especial.
Gana el programa, siempre. La opinión del modelo no cambia la marca: no se usa para decidir, se usa para medir cuánto se equivoca ese modelo. Queda guardada con su costo, y si se equivoca seguido se ve en los números.
El renglón queda sin comprobar. No se marca bien ni mal, y el ejercicio no cierra como «bien». Es el caso que da nombre a la regla: ante la duda, no se inventa un veredicto.
No se evalúa nada todavía: primero se pregunta. Un error de lectura nunca puede convertirse en un error del alumno.
Una anotación al margen, un numerito de simplificación o algo tachado no se evalúan. Quedan guardados y marcados como lo que son.
Se marca como arrastrado, no como un error nuevo. El alumno se equivocó una vez, no tres: lo que importa es dónde empezó.
El camino de un ejercicioCapítulo 13 · Vigente al 16/11/2026
Cuando la app encuentra un error, no alcanza con saber que el renglón está mal: necesita saber qué clase de error es. De eso dependen la explicación que le va a dar, el consejo del tutor y el ejercicio parecido que le va a ofrecer después.
Esa lista de clases de error es el catálogo de tipos de error. Empezó con unos pocos y ahora se amplía sola, con dos inteligencias artificiales que no se ven entre sí y el programa comprobando cada ejemplo.
Con un catálogo corto, la mayoría de los errores caían en un cajón llamado «desconocido». Un error desconocido se puede marcar, pero no se puede explicar bien ni se le puede dar un consejo útil: la app sabe que el renglón está mal y poco más.
Tres pasos, en este orden, y los tres tienen que dar bien:
| Paso | Quién | Qué hace |
|---|---|---|
| 1 · Propone | El modelo de Anthropic | Describe el tipo de error: qué pasó, cómo se hace bien, qué practicar después, y un ejemplo con números |
| 2 · Revisa | El modelo de OpenAI | Lo juzga sin ver la opinión del otro modelo, para que no se contagie |
| 3 · Comprueba | El programa | Hace la cuenta del ejemplo. Si el ejemplo no da, el tipo de error se descarta aunque los dos modelos lo hayan aprobado |
Los que pasan los tres quedan establecidos y la app los empieza a usar. Todas las propuestas quedan guardadas, también las descartadas, con el motivo: así se puede ver qué se rechazó y por qué, en vez de que desaparezca sin dejar rastro.
El catálogo se amplía por tema, no todo junto. Los temas son cuatro, agrupados de a dos:
Por cada grupo se incorporan hasta quince tipos de error nuevos. Hacerlo de a grupos permite medir si lo que entró mejoró las explicaciones antes de seguir ampliando.
Las correcciones viejas quedaron etiquetadas con el catálogo chico, muchas como «desconocido». Cuando el catálogo crece, esas correcciones se vuelven a etiquetar con los tipos nuevos.
Y se hace sin tocar nada de lo anterior: la etiqueta nueva se guarda al lado de la vieja, junto con cuál era antes y por qué cambió. Quien después lee el tipo de error de un renglón usa la nueva si existe.
Ninguna marca de ✓ o ✗ se modifica, y nada de lo que el alumno ya vio cambia. Reetiquetar sirve para que los informes y los consejos futuros sean mejores, no para reescribir la historia. Es la regla general del registro: solo se agrega, nunca se pisa.
Esta parte no se lee de corrido. Son las situaciones puntuales de la clasificación.
Se le pone su tipo y, con él, el consejo que corresponde a ese tipo. Es lo que permite decir «esto se llama así y se evita de esta manera».
Pasa por una inteligencia artificial que solo clasifica, con los nombres y las descripciones de los tipos a la vista. Si igual no encaja, queda como desconocido: no se le fuerza una etiqueta parecida.
Una IA lo propone, otra de otra empresa lo revisa —también el texto que leería el alumno— y el programa comprueba el ejemplo haciendo la cuenta. Recién con los tres pasos queda establecido.
No se usa, y queda listado aparte en la pantalla de Consejos, con el motivo por el que no pasó. Se puede mirar, pero no entra en circulación.
Se vuelve a etiquetar sin tocar lo anterior: queda la etiqueta nueva junto con la vieja, y los informes usan la vigente.
Se rechaza. Las propuestas de una IA tienen el mismo límite de tamaño que los ejercicios que arma el programa: un ejemplo con números gigantes no le enseña nada a nadie.
El camino de un ejercicioCapítulo 14 · Vigente al 16/11/2026
Este es el módulo más grande de la plataforma, y el que decide qué vive el alumno. Va desde que abre un ejercicio hasta que lo cierra: mientras trabaja no se lo interrumpe nunca; si se traba, pide ayuda y recibe escalones cada vez más concretos; cuando sube la foto, se le corrige, se le explica lo que falló y, si hace falta, tiene un segundo intento.
Un ejercicio puede terminar de cinco maneras distintas, y la diferencia entre ellas es lo que después mide si está aprendiendo.
Es una regla fija de la plataforma: nada interrumpe al alumno mientras resuelve. No hay avisos, no hay correcciones en vivo, no hay un cronómetro a la vista. La ayuda existe, pero la pide él.
Lo único que la app mira es si pasó mucho rato sin actividad. Y tampoco lo interrumpe para corregirlo: le pregunta cómo va, con tres respuestas posibles — «Estoy pensando», «Me trabé» o «Me distraje». Cada una lleva a un lugar distinto.
Si toca «¿Te trabaste? Pedí ayuda», no recibe la respuesta. Recibe el escalón que le toca, y cada uno es más concreto que el anterior:
Cada escalón pasa por sus controles antes de mostrarse. Si no los pasa, no se muestra: no se le da una pista que podría estar mal.
No hace falta terminar para pedir una mirada. Con una foto «En proceso», la app lee lo que hizo hasta ahí, él confirma, se evalúa lo que haya, y le dice «vas bien hasta acá» o le marca el renglón para revisar. El ejercicio no se cierra: sigue trabajando.
Con una foto final —«Ejercicio completo» o «Hasta acá llegué»— arranca la secuencia. Cada paso depende del anterior:
| Paso | Qué pasa |
|---|---|
| 1 · Se lee y confirma | Como en cualquier foto: él confirma lo que la app entendió |
| 2 · Se corrige | Renglón por renglón, con el programa decidiendo |
| 3 · Se pregunta la seguridad | Qué tan seguro estaba de lo que hizo. Se guarda para después |
| 4a · Si está bien | Se le dice que salió bien, con el consejo de refuerzo si corresponde. Listo |
| 4b · Si no | Sigue la secuencia de abajo |
| 5 · Pregunta de causa | Qué cree que pasó. No es un examen: ayuda a saber si el error fue de concepto o de distracción |
| 6 · La pista, con su consejo | Un aviso corto para que busque el error solo, con la regla general del consejo del tutor |
| 7 · «¿Ves algo para cambiar?» | Si lo ve, lo corrige. Si no, se le muestra |
| 8 · La lección | Un ejercicio equivalente, resuelto, para que vea cómo se hace |
| 9 · Segundo intento | Vuelve a su ejercicio |
| 10 · El cierre | La devolución completa, el coaching y, si no salió, la explicación optativa |
Recién al final aparece el botón «Mostrame cómo se resuelve este ejercicio». Y hay una regla: al verlo, el ejercicio queda cerrado. No se puede ver la resolución y después decir que salió bien.
No es «bien» o «mal». La diferencia importa, porque es lo que alimenta el perfil de habilidades:
| Cómo terminó | Qué quiere decir |
|---|---|
| Bien, solo | Lo resolvió sin ayuda y sin equivocarse |
| Bien, se corrigió solo | Se equivocó, se dio cuenta y rehízo las cuentas desde donde estaban bien |
| Bien, con una pista | Lo sacó después de que la app le marcara dónde mirar |
| Bien, con una lección | Lo sacó después de ver un ejercicio parecido resuelto |
| Sin resolver | No llegó. Y acá la app distingue si pidió ayuda o no la pidió |
Cada pantalla que se le muestra queda registrada con la hora, el tipo, el texto exacto y de dónde salió. Si lo escribió un modelo, se guarda además cuál, qué controles pasó y cuánto costó.
Eso es lo que alimenta la vista «Lo que vio el alumno» de los tutores, y lo que permite reconstruir después por qué la app dijo lo que dijo.
Hay una instrucción que va en cada pedido a una inteligencia artificial en este módulo: nunca afirmar nada del trabajo del alumno que no esté en sus renglones. Hablar en positivo es decirle qué hacer, no inventarle un logro. Si no hay renglones correctos, no se le reconoce nada como bien hecho.
Esta parte no se lee de corrido. Cubre qué pasa en cada situación del cierre, incluidas las que casi nunca ocurren.
| Pregunta | Cuándo |
|---|---|
| Confirmación | «¿Escribiste esto?», antes de evaluar nada |
| Seguridad | Después de corregir: qué tan seguro estaba |
| Causa | Cuando hubo un error: qué cree que pasó |
| Razonamiento | Cómo lo pensó. No se pregunta cuando el ejercicio salió bien |
| Inactividad | Pasó mucho rato sin actividad: «Estoy pensando», «Me trabé», «Me distraje» |
| Botón | Qué hace |
|---|---|
| 👀 Sí, lo veo / 🤷 No, no veo nada | La respuesta a «¿Ves algo para cambiar?». Si no lo ve, se le muestra |
| 👀 Ver explicación / Cerrar explicación | Abre y cierra la explicación del error. Se guarda cuánto estuvo abierta y cuántas veces la reabrió, pero no se afirma que la haya leído |
| 👀 Ver lección / Seguir sin lección | El ejercicio parecido resuelto, o saltearlo |
| Volver a mi ejercicio | Sale de la lección y vuelve al suyo |
| 📖 Mostrame cómo se resuelve este ejercicio | La resolución de su propio ejercicio. Al verla, el ejercicio queda cerrado |
| Ver otros consejos | Los consejos del tutor que ya recibió para ese tipo de error |
| 🔊 Escuchar | Lee en voz alta el texto escrito, completo, incluido el «igual» |
| Lo retomamos después | Pausa la sesión. El trabajo queda guardado |
| ← Inicio | Vuelve a la pantalla de inicio sin cerrar el ejercicio |
| ⋯ renglones anteriores · Ver todos | Despliega los renglones que la pantalla había plegado |
| Situación | Qué hace la app |
|---|---|
| Falla mientras arma el ejemplo resuelto | No cuenta como intento del alumno. Se reintenta |
| Falla cinco veces seguidas | Se frena: la caída es larga y no tiene sentido seguir intentando |
| La corrección vuelve sin renglones | Aparece «Reintentar»: vuelve a evaluar la última lectura confirmada que sí tenía renglones |
| La sesión se pausó por esa falla | Al retomarla, se reintenta sola una vez |
| Falló durante el día | A los tutores les llega un resumen de qué falló y cuántas veces, en palabras: «hoy falló una IA mientras hacía su tarea: la corrección de los renglones, 3 veces» |
| Acción | Para qué |
|---|---|
| Corregir cómo terminó | El tutor corrige el resultado de un ejercicio cerrado cuando la app lo registró mal. Queda como una anotación nueva, sin pisar la anterior |
| Volver a evaluar una foto | Vuelve a corregir una foto ya evaluada, pero con las reglas de hoy. Sirve cuando una regla cambió y las correcciones viejas quedaron con el criterio anterior |
| Reabrir un ejercicio | Cuando la app lo cerró mal y hay que volver a abrirlo |
| Corregir el enunciado | Si el enunciado entró mal leído, se corrige, y lo corregido vale desde ese momento en adelante |
El camino de un ejercicioCapítulo 15 · Vigente al 16/11/2026
Cuando un ejercicio sale mal, la app no le dice «está mal, fijate». Le explica el error como se lo explicaría un docente sentado al lado: le muestra qué escribió, le dice qué pasó y por qué, le da la regla, le muestra uno parecido resuelto y le dice qué hacer ahora.
Y hay una regla que gobierna todo el módulo: no se inventa nada. Todo lo que la devolución afirma sobre el trabajo del alumno sale de sus renglones, de lo que el programa decidió sobre cada renglón y de lo que dio el verificador. Nunca de lo que un modelo supone.
El error se explica igual en los cinco lugares donde aparece: en el cierre del ejercicio, en «Qué pasó y por qué», en el ejemplo resuelto, en la lección y cuando el alumno pregunta algo. Un solo molde, siempre en el mismo orden.
Eso no es prolijidad: es que el alumno aprenda a leerlo. Si cada lugar explicara distinto, tendría que descifrar el formato antes de entender el error.
| Orden | Parte | Quién la escribe |
|---|---|---|
| 1 | Cuántos errores hay y dónde | El programa |
| 2 | El renglón del alumno, dibujado, con la parte mal resaltada | El programa |
| 3 | Qué hiciste — la cita literal de lo que escribió | El programa |
| 4 | Por qué está mal, con la cuenta correcta | El programa; un modelo puede redactarlo más claro si pasa los controles |
| 5 | La regla, en su recuadro aparte | El programa |
| 6 | Lo demás está bien | El programa, y solo si hay renglones correctos |
| 7 | El consejo del tutor | Capítulo aparte |
| 8 | Qué hacer ahora | El programa |
La inteligencia artificial participa poco y en un lugar acotado: puede redactar más claro lo que el programa ya determinó. No puede decidir qué está mal, ni por qué, ni inventar una causa.
Lo que recibe el modelo es solo esto: los renglones que el alumno confirmó, el veredicto de cada uno, el tipo de error, lo que el programa encontró mirando los números —por ejemplo, «sumó los denominadores: 2 + 3 = 5»— y, si el ejercicio terminó, la resolución verificada. Nada más.
«Hablar en positivo» significa decirle qué hacer, no inventarle algo que hizo bien. Si no hay ningún renglón correcto, no se le reconoce nada, porque no habría nada que mostrarle como prueba. Un control en código revisa cada afirmación de la devolución contra los renglones reales y rechaza la que no tenga respaldo.
Arriba de todo, la devolución le muestra su propia resolución con cada renglón marcado:
Y cuando se corrigió solo, las marcas cambian para contar esa historia: «acá te equivocaste» y «✓ acá te corregiste». No es lo mismo equivocarse que equivocarse y darse cuenta, y la pantalla lo dice.
La parte 2 del molde dice «el renglón del alumno, dibujado, con la parte mal resaltada». Vale la pena verlo, porque es lo primero que mira el chico y es lo que hace que entienda el error sin leer nada.
Sigamos con el ejercicio del capítulo 11. El alumno escribió esto en el renglón 3:
No se resalta el renglón entero: se resalta la parte exacta que está mal, en este caso el signo. Eso lo decide el programa, no un modelo: compara término por término el renglón con el anterior y sabe cuál no cierra.
Tres reglas de cómo se resalta:
Todo lo que la devolución muestra se puede escuchar. En la pantalla del ejercicio hay un menú 🔊 Voz arriba, y un botón 🔊 Escuchar en cada explicación.
La regla de fondo es la misma que gobierna el módulo, aplicada al sonido: el audio se arma del texto escrito, nunca de un texto aparte. Una IA no puede mandar «lo que hay que decir en voz alta»; si lo manda, se ignora. Lo que se escucha es, palabra por palabra, lo que está en la pantalla.
Y una cosa que suena rara hasta que se piensa un segundo: la voz dice todo, incluido el «igual». Un lector automático común leería «7 + 19/16 = 8,19» saltándose signos o diciendo «diecinueve sobre dieciséis». Acá el programa pasa la cuenta a palabras antes de leerla:
Escrito: 1/3 + 1/6 = 1/2
Dicho: «un tercio, más, un sexto, es igual a, un medio»
Cada número, cada signo y cada operación se dicen. El «igual» se dice «es igual a». Las comas son las pausas. No queda ninguna cifra sin decir, y no se lee ningún símbolo como símbolo.
Es la misma regla que ordena todas las explicaciones de la plataforma: se dice cada paso completo y con su porqué, sin dar nada por sabido. Un chico que escucha en vez de leer tiene que recibir exactamente lo mismo, no una versión resumida.
El menú de voz deja elegir cuál voz —solo las voces en español que tenga el equipo— y a qué velocidad: lenta, normal o rápida. Si el equipo no tiene ninguna voz en español, el menú lo dice y explica dónde se agregan, en vez de quedarse mudo sin motivo.
Son dos cosas distintas y conviene no confundirlas:
Los dos se arman con el mismo criterio —el programa decide, la IA a lo sumo redacta— y los dos quedan guardados por separado en «Lo que vio el alumno».
Una devolución larga no se lee. El módulo tiene topes duros:
| Qué | Tope |
|---|---|
| La devolución entera | 60 palabras |
| Lo que puede escribir un modelo en «Qué pasó» | 35 palabras |
| Lo que puede escribir en «Ahora probá» | 18 palabras |
| Mínimo de «Qué pasó» para que valga la pena | 10 palabras |
El tope de un modelo se recalcula según cuánto ocupen la cita del renglón y el reconocimiento, para que el total no se pase.
Los renglones se numeran de una sola manera: la de «Tu resolución», que es la misma que el alumno vio en la pantalla de lectura. Si el programa agregó algún renglón intermedio, el número de la pantalla dejaría de coincidir con el de su hoja. En ese caso la devolución no dice un número que no coincide: dice «tu último renglón», o el número de «Tu resolución».
Esta parte no se lee de corrido. Cubre qué aparece en cada situación y los controles que impiden que la devolución diga algo falso.
Antes de que intervenga ningún modelo, el programa identifica qué hizo el alumno. Son acciones concretas que puede nombrar con certeza, por ejemplo: «sumó los denominadores entre sí», «sumó los numeradores». Esas descripciones salen de un catálogo, no de una interpretación.
| Bloque | Siempre | Qué pasa si falta |
|---|---|---|
| Lo que hiciste | Sí | Es la cita literal: no puede faltar |
| Qué pasó y por qué | Sí | Si el programa no sabe qué pasó en ese renglón, el modelo puede sumar — y ahí es el único lugar donde tiene margen |
| Cómo se hace | No | Si no se pudo armar un ejemplo parecido, el bloque no va y se avisa a los tutores |
| Ahora probá | Sí | — |
| Situación | Qué dice |
|---|---|
| Un error, y lo rehízo | En qué renglón se equivocó y, si el programa lo sabe, por qué. Las marcas son «acá te equivocaste» y «✓ acá te corregiste» |
| Varios errores, y los rehízo | Lo mismo, con el texto que corresponde a la cantidad |
| Se corrigió solo | Nunca se le dice «cada renglón es igual al anterior» con un renglón marcado en rojo: sería contradictorio. El texto es fijo y el modelo no lo puede reescribir |
En «Lo que vio el alumno» queda la devolución en texto plano: los bloques por un lado y el pizarrón por otro, con el texto exacto que se mostró. Eso permite reconstruir después qué se le dijo, palabra por palabra.
El camino de un ejercicioCapítulo 16 · Vigente al 16/11/2026
Cuando hay que mostrarle cómo se resuelve algo, la app no escribe un texto que lo explique: lo resuelve en el pizarrón, como lo haría un docente. Escribe la cuenta entera y la vuelve a escribir entera en cada renglón, cambiando una sola parte por vez y marcándola con color.
Lo arma el programa solo, sin inteligencia artificial, y comprueba cada renglón antes de mostrarlo. Si algo no cierra, no hay pizarrón: no se muestra una resolución a medias.
El programa lee la cuenta, busca qué se resuelve primero según el orden de las operaciones, lo marca y escribe debajo una línea corta con esa cuenta y su porqué. Después repite.
| Orden | Qué se resuelve |
|---|---|
| 1.º | Los paréntesis |
| 2.º | Las potencias y las raíces |
| 3.º | Multiplicar y dividir |
| 4.º | Sumar y restar |
Cada parte se marca con el color de su nivel, así el alumno ve por qué se resolvió eso primero y no otra cosa.
Y hay un renglón propio para un caso que confunde a todos: sumar fracciones con distinto denominador. En vez de hacerlo en el mismo paso, el pizarrón dedica un renglón a «primero el mismo denominador», porque son dos cosas distintas y conviene verlas separadas.
Mostrarle una resolución equivocada es peor que no mostrarle ninguna. Por eso cada renglón del pizarrón se comprueba con el verificador, con fracciones exactas, contra dos condiciones:
Si cualquiera de las dos falla, no hay pizarrón. No se muestra la parte que sí dio.
Cuando el alumno está trabado, mostrarle su propio ejercicio resuelto le da la respuesta y termina el ejercicio. Así que el pizarrón arma uno parecido: cambia los números manteniendo la forma de la cuenta.
Es una regla fija de la plataforma: no se le muestra su propio resultado antes de tiempo.
Esta parte no se lee de corrido. Cubre dónde se usa el pizarrón, qué entiende y qué pasa cuando no se puede armar.
| Dónde | Con qué cuenta |
|---|---|
| En la devolución, en «Cómo se hace» | Con un ejercicio parecido, nunca con el suyo |
| En la lección, cuando pide ayuda | Con un ejercicio equivalente resuelto |
| En «Mostrame cómo se resuelve este ejercicio» | Con el suyo. Al verlo, el ejercicio queda cerrado |
El pizarrón resuelve una sola operación por renglón, no varias del mismo escalón juntas. Un renglón que resuelve tres multiplicaciones a la vez es correcto pero no se puede seguir con el dedo; de a una, sí.
La misma del verificador: las fracciones con barra, el acento circunflejo para las potencias, el punto a media altura para multiplicar, los dos puntos para dividir, y las raíces escritas como función. Es la misma notación en la que se leen las hojas, así que no hay traducción en el medio.
| Situación | Qué pasa |
|---|---|
| Un renglón no vale lo mismo que el anterior | No se muestra nada |
| Un renglón cambió algo además de lo marcado | No se muestra nada |
| No se pudo armar el ejemplo parecido | El bloque «Cómo se hace» no aparece, y les llega un aviso a los tutores |
| La cuenta no se puede leer | No hay pizarrón; el error se explica igual, sin él |
Es una decisión de fondo de la plataforma, no una limitación técnica. Un modelo escribe resoluciones que casi siempre están bien, y ese «casi» es el problema: una resolución equivocada en el lugar donde el alumno va a aprender cómo se hace deja un error aprendido que después cuesta sacar. El programa, en cambio, calcula con fracciones exactas y comprueba cada renglón, así que no puede equivocarse: puede, como mucho, no poder hacerlo.
El camino de un ejercicioCapítulo 17 · Vigente al 16/11/2026
Cuando el alumno termina un ejercicio, la app no se queda en explicarle el error: además le da un consejo, como se lo daría un maestro sentado al lado. No es la explicación del error ni la resolución: es una forma de trabajar o de controlarse que le va a servir en los próximos ejercicios.
Un elogio no es un consejo. «¡Muy bien!» no cuenta, y la app lo rechaza.
Hay dos clases de consejo:
Ejercicio 5.a de la tanda «Repaso de Operatoria 2». El enunciado que el alumno tenía en la hoja:
Esto es lo que escribió, renglón por renglón:
Es una resta y no una suma, porque
Explicarle el error alcanza para ese ejercicio. El consejo apunta a lo de al lado: cómo podría haberse dado cuenta solo. Esto es lo que ve al cerrar:
Antes de escribir el resultado, mirá el tamaño: si restás más de lo que sumás, tiene que quedar por debajo de donde estabas.
En tu ejercicio: tiene que quedar por debajo de 7.Ese 7 no lo escribe la inteligencia artificial: lo calcula el programa, juntando los números enteros del renglón anterior al error (8 − 1 = 7). Es la regla de toda la app: la matemática la decide el programa, nunca un modelo.
| Parte | Qué es | Quién la escribe |
|---|---|---|
| La regla general | Sirve para cualquier ejercicio de ese tipo. Se guarda y se vuelve a usar con otros alumnos y otros ejercicios. Como máximo 35 palabras. | La redacta un modelo de inteligencia artificial, una sola vez, y queda guardada |
| «En tu ejercicio» | La misma regla, aplicada a los números que el alumno tiene adelante. | Es un texto con huecos; los números los pone el programa en el momento |
Esa división es la que hace que el consejo salga barato y no se equivoque: la parte que piensa se escribe una vez, y la parte que tiene números no pasa por ninguna inteligencia artificial.
La regla general aparece antes que el consejo completo. Cuando la app le avisa que hay un error para que lo busque solo, le muestra solo la regla general, sin la parte de «en tu ejercicio», que le daría la respuesta servida.
Los consejos no se inventan de a uno en el momento. Hay un catálogo: una lista de consejos guardados, ordenados por tipo de error. Entran por tres caminos:
| Camino | Cómo entra | Quién lo habilita |
|---|---|---|
| La siembra | Una corrida arma dos o tres consejos para cada tipo de error conocido, de una sola vez. | Los que pasan todos los controles quedan aprobados solos. El tutor puede desactivar cualquiera. |
| En el momento | Si aparece un error de un tipo que no tiene ningún consejo, se arma uno de fondo, sin hacer esperar la pantalla. | Entra solo si pasa los controles, y les llega un aviso a los tutores. |
| Repetición | Si el alumno ya recibió todos los consejos de ese tipo de error, se arma uno nuevo de fondo. | Mientras no esté listo, se repite el mejor puntuado. |
Cada consejo guardado está en uno de tres estados: sin aprobar, aprobado o desactivado. El alumno solo ve los aprobados.
El que más sirvió. La app lo mide sola: si después de dar un consejo el error no vuelve a aparecer en los cinco renglones siguientes donde podría aparecer, ese consejo suma un punto. Ante el mismo error se ofrecen primero los que más puntos tienen; si empatan, el más antiguo.
Un consejo equivocado es peor que ningún consejo: el alumno se lo lleva a todos los ejercicios siguientes. Por eso cada uno pasa cuatro controles, y los hacen partes distintas.
| Paso | Quién | Qué comprueba |
|---|---|---|
| Lo redacta | El modelo de Anthropic | Lo escribe en el «vos» del alumno, pensado para que lo lea fácil un chico de 12 a 17 años. Si se pasa de 35 palabras, se le vuelve a pedir. |
| Calcula los números | El programa | Todo número que aparezca lo pone el programa. Si el texto trae una cuenta falsa, se frena ahí. |
| Casos trampa | El programa y el modelo de OpenAI | El consejo se aplica a ejercicios elegidos a propósito para romper los atajos. Si en alguno lleva a un resultado equivocado, se descarta. |
| Lo revisa | El modelo de OpenAI, nunca el mismo que lo escribió | Que no regale la respuesta, que no enseñe algo nuevo y que no diga nada falso. Solo puede rechazarlo citando la frase que está mal. |
«Cuando un número cambia de lado, cambia de signo» suena a buena regla y es falsa: en
Si una de las inteligencias artificiales no contesta, tarda de más o devuelve algo roto, el cierre se muestra completo igual, sin consejo, y queda anotado el motivo. La pantalla nunca queda sin salida, y el alumno nunca espera por un consejo.
Además, el mail y el informe nombran qué consejos se dieron y si después el error volvió. Los avisos llegan cuando se descartó un consejo, cuando se armó uno nuevo y cuando aparece un tipo de error que todavía no tiene consejo.
| Qué | Valor |
|---|---|
| Largo máximo de la regla general | 35 palabras |
| Veces que se vuelve a pedir un consejo descartado | 3 |
| Cada cuántos ejercicios bien puede salir un refuerzo | 3 |
| Renglones sin el error para que un consejo sume un punto | 5 |
Esta parte no se lee de corrido. Son las situaciones del consejo y los botones del catálogo.
La parte de «en tu ejercicio» la arma el programa, con un texto fijo de huecos que llena con los números reales. No la escribe una IA en cada cierre.
Editar el texto de un consejo no está por ahora: es una decisión tomada, no algo que falte.
Si pasa todos sus controles, entra solo y la campanita avisa. La diferencia con los sembrados es el momento: uno se arma con tiempo y espera aprobación; el otro se arma cuando hace falta y ya pasó todo.
Se repite el anterior de ese tipo. Mejor el consejo de la vez pasada que ninguno.
No lleva consejo ni se siembra uno. Sin saber qué pasó, un consejo sería una frase hecha.
Un consejo suma un punto si, después de darse, el error no vuelve en los cinco pasos siguientes de ese tipo —renglones de la misma habilidad, en ocasiones distintas, sin contar el ejercicio donde se dio—. Ante un error nuevo se ofrece primero el que tiene más puntos.
El camino de un ejercicioCapítulo 18 · Vigente al 16/11/2026
Cuando un alumno se equivoca, lo que menos sirve es darle otra vez el mismo ejercicio: ya vio el resultado. Lo que sirve es otro ejercicio del mismo tipo, con otros números, para que vuelva a poner en juego la misma habilidad. Eso es un parecido.
Dos palabras que no son lo mismo. Un parecido es el que arma la plataforma sola, cuando un ejercicio no salió o cuando hace falta otra ocasión. Un gemelo es el que un adulto pide a mano con el botón «Dar un gemelo», y exige más: cambia la organización de la cuenta, no solo los números. En el resto del documento, «gemelo» aparece únicamente cuando lo pide un adulto.
La regla que ordena todo el módulo: el programa elige los enunciados; la inteligencia artificial solo los resuelve y los explica. Nunca al revés.
Si se le pidiera a un modelo «dame un ejercicio parecido a este», devolvería algo que parece parecido. A veces sería más fácil, a veces más difícil, a veces otro tema. El alumno practicaría otra cosa sin que nadie se entere.
El programa, en cambio, lee el ejercicio original con un lector propio y arma una ficha del ejercicio —que no es el perfil de habilidades del alumno, es la descripción de este ejercicio—: qué habilidades exige, cuál es la que falló, qué rasgos no se pueden cambiar y qué errores típicos tiene. Después genera candidatos variando los números dentro de lo que esa ficha permite. Cada candidato pasa por todos los controles antes de ser siquiera considerado.
| Paso | Quién | Qué hace |
|---|---|---|
| 1 · Lo ya hecho | El programa | Busca si ya hay uno preparado para ese alumno o uno en el banco compartido, y lo revalida contra este original |
| 2 · Elegir enunciados | El programa | Elige hasta tres enunciados de la lista de válidos |
| 3 · Resolver | Un modelo | Los resuelve paso a paso |
| 4 · Controlar | El programa | Comprueba cada resolución: que cada renglón valga lo mismo, que el resultado sea el que el programa calculó, y que tenga entre 3 y 8 renglones distintos |
| 5 · Revisar | Un modelo de otra empresa | Opina, y tiene que citar el texto exacto de lo que está mal. Un «falla» sin cita no vale |
| 6 · Elegir y guardar | El programa | Se usa uno, y los demás aprobados van al banco compartido para otra vez |
Si no queda ninguno, hay un segundo intento con otros enunciados. No hay un tercero, y no hay árbitro: si después de dos vueltas no hay un parecido confiable, no se da ninguno.
El motor no sabe analizar todo. Hay ejercicios con letras, con porcentajes o con inecuaciones que todavía no puede perfilar. En esos casos no inventa: devuelve que no tiene perfil, y dice qué es lo que le falta.
Ese parecido queda «Para revisar» y lo ve un tutor en Pendientes. El alumno no recibe nada armado a medias.
Además del parecido automático, un tutor puede dar uno a mano desde un ejercicio cerrado. Se llama «Dar un gemelo», y tiene una regla de fondo:
El alumno no tiene nada hasta que un tutor aprueba el parecido que se armó. Se eligen cuántos (uno, dos o tres), cada uno se arma por separado con sus etapas a la vista, y al terminar el tutor decide: Asignar o No asignar. Lo que no se asigna no vuelve al banco para nadie.
Si el tutor cierra la ventana sin decidir, el pedido queda «Para revisar» en Pendientes. No vence, y al alumno no le llega nada mientras tanto.
Es una decisión explícita y va contra lo intuitivo. Si un gemelo cambia únicamente los números, el alumno repite el procedimiento de memoria sin volver a pensarlo: hace la misma secuencia de pasos con otras cifras.
Por eso los gemelos cambian la organización de la cuenta, manteniendo la habilidad. Es más caro de armar y más lento, y se acepta: de 30 segundos a 1 minuto por gemelo, y hasta 10 minutos para una tanda de diez.
Con un límite de sentido común: donde una parte del ejercicio no admite variación, se deja como en el original. Forzar un cambio ahí produciría un ejercicio distinto, no un gemelo.
Esta parte no se lee de corrido. Cubre los controles que pasa cada parecido, cómo funciona el banco compartido y qué se ve cuando algo falla.
Antes de pedirle a ningún modelo que lo resuelva, el enunciado tiene que pasar los controles del programa: que mantenga las habilidades del original, que conserve los rasgos que no se pueden tocar, que los números estén dentro de la banda permitida y que el resultado no sea el mismo que el del original.
| Qué se controla | Qué exige |
|---|---|
| Cada renglón | Vale lo mismo que el anterior, con fracciones exactas |
| El resultado | Es el que calculó el programa, no el que dice el modelo |
| La cantidad de pasos | Entre 3 y 8 renglones distintos. Menos no enseña nada; más es ilegible |
El segundo modelo, el que revisa, también está controlado: si dice que un candidato falla, tiene que citar literalmente la parte que está mal. Un rechazo sin cita no se acepta. Es para que no pueda frenar un ejercicio correcto con una opinión vaga.
| Regla | Detalle |
|---|---|
| Se comparte entre alumnos | Un parecido aprobado sirve para otro alumno con el mismo tipo de ejercicio |
| No se repite | A un alumno no se le da uno que ya usó |
| Se revalida | Antes de usar uno guardado, se comprueba de nuevo contra el original de ahora |
| Queda lo que se ahorró | Cada uso anota cuánto se evitó gastar en inteligencia artificial |
| Lo que no se asigna no entra | Un gemelo que el tutor no aprobó no vuelve al banco para nadie |
Se comparten los enunciados, las resoluciones y las explicaciones que no dependen de los renglones de un alumno. Todo lo que habla de lo que escribió una persona concreta no se comparte nunca.
| Etapa | Qué muestra |
|---|---|
| 1 · Preparado | Si ya había uno listo para ese alumno |
| 2 · Banco | Si se encontró uno en el banco compartido |
| 3 · La cadena completa | El generador, el control del programa y el revisor. No hay árbitro: si después de dos vueltas no hay un parecido confiable, no se da ninguno |
| Al terminar | Asignar o No asignar; después, Armar otro o Dejar el pedido sin parecido |
| Situación | Qué pasa |
|---|---|
| El ejercicio tiene letras, porcentajes o inecuaciones | Sin perfil: queda «Para revisar» y se dice qué le falta al motor |
| Ningún candidato pasa los controles, dos veces | No se da parecido. No hay tercer intento ni árbitro |
| El tutor cierra la ventana sin decidir | Queda «Para revisar» en Pendientes. No vence |
| Un parecido asignado que el alumno no hizo | Se ve en Pendientes, con «Quitar parecido» |
| La app sabe enseñar el tema pero no armar parecidos de ese tipo | En general el ejercicio se da igual, y el parecido queda «Para revisar». Si la tanda tiene marcada la práctica con parecidos como obligatoria, el ejercicio queda en espera |
| Se pide desde el celular | «Dar un gemelo» es solo desde la computadora |
Un gemelo que cambia la organización de la cuenta tarda más que uno que cambia números. Los tiempos aceptados son de 30 segundos a 1 minuto por gemelo, y hasta 10 minutos para una tanda de diez.
Entiende decimales exactos y periódicos —el período entre paréntesis—, fracciones, potencias con exponente negativo, raíces de cualquier índice, módulo y las combinaciones de todo eso. Lo que no entiende lo dice, en vez de intentarlo igual.
Lo que ven los tutoresCapítulo 19 · Vigente al 16/11/2026
Los adultos tienen su propio lado de la aplicación. Todas sus pantallas comparten un menú arriba, siempre igual, con tres grupos: Práctica, Informes y Ajustes. Al lado del nombre de la aplicación hay un selector de alumno: todo lo que se ve y se carga es de ese alumno.
El alumno no ve ese menú ni ninguna de esas pantallas. No es que estén escondidas: sus pantallas no pasan por ahí.
De izquierda a derecha, en la PC:
| Parte | Qué hace |
|---|---|
| loaprendi | Vuelve al Inicio de los adultos |
| Alumno: ▾ | Elige de qué alumno es todo lo que se ve. Con un solo alumno no es un selector: solo dice su nombre |
| Práctica | Tandas abiertas · Cargar tanda · Armar sesión · Pendientes |
| Informes | Informe por fechas · ¿Está aprendiendo? · Costos |
| Ajustes | Ficha del alumno · Valores por defecto · Qué sabe el programa · Consejos del tutor · Permisos · Accesos |
| Campanita | Los avisos, con el número de los que no se leyeron |
| Nombre · Salir | Quién entró, y cerrar la sesión |
En el celular quedan arriba el nombre de la aplicación, la campanita y un botón ☰, que abre la misma lista con los tres grupos uno debajo del otro. Se cierra con la ✕, tocando afuera o eligiendo una pantalla.
Es lo primero que ve un tutor al entrar. Responde una sola pregunta —cómo viene el alumno— y ofrece los caminos más usados. De arriba hacia abajo:
Los datos del alumno, en tres bloques: Quién es (nombre o apodo, fecha de nacimiento, año o grado, zona horaria), Su cuenta (su mail de Google, si está activo, su tope de gasto de IA por mes) y A quién le llegan los mails.
Cada destinatario recibe Completo (todo) o Resumen (sin costos ni perfil). El mail del alumno nunca recibe resúmenes: es la dirección a la que le llegan sus recordatorios de repaso, y es dato de un menor, así que no aparece en informes ni en mails a otras personas.
Hay un solo Guardar para toda la pantalla, con Deshacer al lado, y arriba el conteo de cambios sin guardar. Cada cambio queda en el historial con quién, cuándo y el valor anterior. Recibir mails no da acceso a la aplicación: eso se da en Accesos.
Son cuatro permisos, y todos son del alumno: Empezar una sesión, Retomar una pausada, Armar una sesión y Crear tanda. Cada uno tiene su «?» que explica qué pasa si se lo sacás —por ejemplo, sin «Empezar una sesión» sus tarjetas se siguen viendo pero no arrancan: espera que un tutor le arme la sesión—.
Los tutores tienen todos los permisos, los dos por igual, y eso no se cambia desde acá. Cada toque de un interruptor se guarda en el momento, con quién y cuándo.
Son los números y las opciones con los que empiezan las tandas y las sesiones nuevas. Las que ya existen siguen con los suyos: cambiar un valor acá nunca altera algo que ya está andando.
Cada valor muestra el actual, el de fábrica y, si no coinciden, una marca CAMBIADO. También dice en qué otro lado se puede cambiar (en una sesión, en una tanda, en un alumno). El «?» contesta siempre las mismas cuatro preguntas: qué es, para qué sirve, qué pasa si lo cambiás y un ejemplo.
Entrar y poder hacer algo son dos cosas distintas, y están en dos pantallas distintas a propósito. Accesos dice quién entra; Permisos, qué puede hacer una vez adentro.
Cada persona entra con su cuenta de Google. Al entrar, el sistema compara ese mail con la lista. Si no está, o si el acceso venció o se quitó, no entra, y el intento queda anotado abajo con el motivo y la hora.
Dentro de Accesos está también el nombre del alumno: el que usa el saludo de su pantalla. Si su cuenta de Google trae otro nombre, la aplicación lo muestra como sugerencia y no lo usa hasta que un tutor toca «Usar este nombre». Cambiar el nombre no pisa el anterior: agrega una fila al historial.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto: en qué situación aparece cada botón, qué hace y qué pasa después. Cubre los controles de las seis pantallas de este capítulo.
El menú no se dibuja y la pantalla dice «Esta pantalla es de los tutores». No es la pantalla la que decide: el servidor contesta que no y la pantalla muestra ese mensaje. El alumno nunca llega acá, porque sus pantallas no pasan por este menú.
Si el servidor contesta que la pantalla no es suya, no se muestra el resumen en espera: se muestra solo «Esta pantalla es de los tutores».
Si el guardado falla, aparece «No se pudo guardar el cambio. Probá de nuevo en un rato» y el interruptor queda como estaba: la pantalla nunca muestra un permiso que el servidor no aceptó.
Queda anotado en «Intentos que no entraron», con el mail, la hora, el alumno y el motivo en palabras: No está en la lista, Acceso vencido o Acceso quitado. No hay nada que tocar: es para enterarse. Si no hubo ninguno, dice «Ninguno».
Lo que ven los tutoresCapítulo 20 · Vigente al 16/11/2026
Son las dos pantallas donde un tutor mira el trabajo. Tandas abiertas responde «¿en qué anda cada tarea?»: una tarjeta por tanda, con su estado y sus números. Pendientes responde «¿qué quedó sin resolver?»: un ejercicio por tarjeta, con qué pasó y qué sigue.
Los dos usan los mismos números y los mismos colores que ve el alumno en sus tarjetas, dichos para adultos. No hay dos contabilidades.
Una tanda pasa por estos estados, y el color del borde los repite:
| Estado | Qué quiere decir |
|---|---|
| En preparación | Se está cargando o verificando. El alumno todavía no la ve |
| Lista para dar | Terminó de verificarse. El alumno la ve recién cuando el tutor toca «Dársela» |
| Cargada | Ya se la dieron y todavía no la empezó |
| En curso | Hay una sesión abierta ahora |
| Pausada | Empezada, sin sesión abierta, con ejercicios sin terminar |
| Falta repaso | Trabajada entera, con repasos pendientes |
| Cerrada | Terminó su último repaso, con o sin pendientes |
Los cinco números de cada tarjeta son: total (todos los ejercicios de la tanda), sin hacer (todavía no se empezó), a medias (quedaron a medias y se pueden retomar), no salió, cerrado (no salió y se cerró: no se retoma, más adelante entra un parecido) y salieron bien (resueltos y confirmados). Debajo, una barra muestra los cuatro últimos en proporción, con el mismo color que cada número.
Cada tarjeta trae además el título, para cuándo es, quién la subió y cuándo, esos cinco números con su barra, cuándo fue la última sesión, cuántos días lleva sin tocarse y en qué andan los repasos.
Una tanda nunca aparece sola en la pantalla del alumno. Termina de verificarse, queda Lista para dar, y espera. El texto lo dice: «Mirá lo que se leyó y quitá lo que esté mal antes de dársela.»
Lo mismo con lo que se agrega después: si se suman ejercicios a una tanda que el alumno ya tiene, la tarjeta avisa «N ejercicios nuevos que todavía no ve · Dárselos». Hasta que un tutor lo toca, no los ve.
Los tres grupos contestan tres preguntas distintas:
Con más de un alumno, la pantalla arranca mostrando el del menú y ofrece «Todos los alumnos»; en ese caso agrupa por alumno, del que más tiene al que menos, y cada tarjeta lleva el nombre.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto: en qué situación aparece cada botón, qué hace y qué pasa después.
Mientras tanto, la tarjeta muestra «Preparando… (3 de 7)» y dice quién la empezó, cuándo, y que el alumno todavía no la ve.
Si no hay ninguna tanda: «Todavía no hay tareas cargadas.» Si el filtro deja la lista vacía: «Ninguna tanda en ese estado.»
Cuando el ejercicio original ya salió de Pendientes pero su parecido sigue pedido o asignado, aparece arriba un bloque verde, Parecidos pedidos, para que ninguno quede olvidado.
Lo que ven los tutoresCapítulo 21 · Vigente al 16/11/2026
Hay cinco informes, y cada uno contesta una pregunta distinta. Por fechas: ¿qué pasó entre estos dos días? De una tanda: ¿cómo le fue con esta tarea? De una sesión: ¿qué pasó hoy? La línea de tiempo: ¿en qué orden exacto pasó todo? Y «¿Está aprendiendo?»: ¿esto le queda?
Ninguno da una nota. Todos cuentan lo que pasó, con sus números. Y cuando algo todavía no se puede calcular no ponen un cero, que se leería como «le fue mal»: ponen una palabra —«pendiente», «pocos datos»— en el lugar de la cifra.
Es el informe más distinto de todos, porque no mide lo que le salió hoy. Mide dos cosas, en este orden:
Debajo va la segunda barra, «con ayuda, en el momento», que es la fácil: sirve de contraste, no de conclusión. Y cuando no alcanzan los datos, la habilidad se marca «Pocos datos»: la barra se dibuja vacía y en el lugar del número va esa palabra. Vacía no es lo mismo que cero, y por eso no lleva cifra.
«Pocos datos», «Todavía no hubo repaso», «Falta el primer repaso», «Todavía no se probó». El informe prefiere decir que no puede afirmar algo antes que estirar dos aciertos hasta una conclusión. Un informe que siempre tiene una respuesta no sirve para decidir nada.
El informe se mira por período —últimas 2 semanas, este mes, desde el principio, o eligiendo fechas— y se puede bajar como PDF o como CSV. Trae además los errores que más se repiten (la misma causa o la misma habilidad dos veces o más) y «Lo que pasó afuera»: cosas anotadas a mano que pueden explicar un cambio, como una enfermedad o una semana de exámenes.
Es el informe general: qué pasó entre dos días cualesquiera. Trae los atajos (Hoy, Ayer, Esta semana, Últimos 7 días, Últimos 30, Este mes, Todo), el rango dicho en palabras, los números grandes y después, en orden: día por día, las sesiones del período una por una, las tandas tocadas, las habilidades tocadas con su antes y después, los errores que se repitieron y los avisos que llegaron en esas fechas. Cierra con «Para leer estos números», que explica qué significa cada uno.
Si en esas fechas no practicó, lo dice así —«En estas fechas no practicó»— y ofrece ir al resumen de la última vez que sí.
Mira una tarea entera: cuántos ejercicios subieron, cuántos parecidos se armaron, cuántos firmes, cuántos no le salieron y cuántos quedaron a medias. Después, un renglón por ejercicio, con la cuenta dibujada, cómo le fue y cuánta ayuda usó. Al final, habilidades: antes → después, con una flecha ▲ en las que subieron.
Desde cada ejercicio se puede dar un gemelo, y desde la cabecera se vuelve a Tandas abiertas.
Es el informe de un rato de trabajo. Mientras la sesión sigue abierta se muestra marcado como «BORRADOR, en curso», con un botón para actualizarlo; al cerrarse, pasa a «Terminada». Tiene:
| Bloque | Qué trae |
|---|---|
| Qué pasó, en pocas líneas | El resumen escrito, para leer de corrido |
| Para que lo veas vos | Lo que conviene que mire un adulto |
| Ejercicios | Cómo le fue en cada uno: le salió, no le salió, empezado a medias, sin hacer |
| Habilidades | Antes → después de la sesión. Se calcula al cierre |
| Ratos de la sesión | Cada vez que entró, hasta que se cortó, con su barra |
| Más detalle | Fecha, duración, pausas e interrupciones, quién la abrió, cómo cerró, modo de preguntas y tanda |
Un tutor puede además dejar escrita una sugerencia para la próxima sesión.
Es el informe de último recurso: cuando algo no cierra, acá está el orden exacto. Cada renglón trae la hora con segundos y milésimas, la etiqueta del evento, qué pasó y quién lo hizo —el alumno, un tutor o el sistema—. Los filtros agrupan por clase: Sesión, Fotos y lectura, Ayudas, Pausas, Cortes y errores, Adultos.
Las milésimas se pueden apagar, pero están por una razón: cuando dos cosas pasan casi juntas, el orden entre ellas es justamente lo que hay que ver.
Se abre desde un informe y muestra un solo ejercicio terminado, completo: cómo quedó, lo que escribió renglón por renglón con sus marcas, la devolución que vio, las pistas y ayudas que tuvo, cómo se resuelve —y si lo miró o no— y sus fotos. Es la forma de ver exactamente lo mismo que vio el alumno, sin interpretaciones.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto: en qué situación aparece cada botón, qué hace y qué pasa después.
Con muchas fechas tarda, y lo dice: «Armando el informe… con muchas fechas puede tardar un poco.» Nunca queda en blanco sin explicación.
Si todavía no hay con qué: «Todavía no hay datos para este informe.»
Cada habilidad es una tarjeta con dos barras y dos preguntas. Las respuestas posibles son pocas y están dichas en palabras, no en números:
Una habilidad marcada «Pocos datos» muestra las barras vacías y la palabra «pocos datos» en lugar de la cifra: no se dibuja un porcentaje que no se sostiene.
Si la tanda todavía no tuvo sesiones: «Todavía no hay una tanda con sesiones.»
Se abre con una sesión concreta desde el resumen; si se entra sin indicar cuál, muestra la última del alumno.
Si el ejercicio todavía no terminó: «Todavía no lo terminó. Se puede mirar cuando lo termine.» Un ejercicio en curso no se mira desde acá, para no espiar mientras trabaja.
Lo que ven los tutoresCapítulo 22 · Vigente al 16/11/2026
Cuando pasa algo que un adulto debería saber, la plataforma avisa por dos caminos: la campanita, que está arriba en todas las pantallas de los tutores, y el mail. No todo va por los dos: lo urgente o lo que pide una decisión va por los dos; lo demás, solo a la campanita.
Hay una regla que atraviesa todo: el silencio no es aprobación. Un aviso que nadie leyó sigue pendiente, y un caso que nadie decidió sigue «sin decidir».
Al tocarla se abre la lista de los avisos sin leer. Cada uno dice cuándo pasó, qué pasó, qué hacer y, si era un mail que no salió, a quién no le llegó. Hay además una pantalla completa de avisos, con filtros «Sin leer / Todos».
Los avisos vienen de dos tipos, y la tarjeta lo dice con una etiqueta:
| Qué pasó | Campanita | |
|---|---|---|
| Un repaso llegó al máximo de vueltas | Sí | Sí |
| Una tanda cerró con pendientes | Sí | Sí |
| Un repaso no se hizo en su día | Sí | Sí |
| Un error del sistema | Sí | Sí |
| Un tema sigue sin resolver en dos sesiones seguidas | Sí | Sí |
| Un caso quedó en la cola sin decidir | Sí | Sí |
| Gasto de IA al 80 % o al 100 % del tope del alumno | Sí | No |
| No pudo salir un mail | Sí | No |
Los dos últimos no van por mail a propósito: avisar por mail que un mail no salió sería absurdo, y el tope de gasto por alumno solo avisa, nunca corta.
De cada aviso queda registrado a quién fue, por qué canal, con qué texto, si se entregó o falló, cuál fue el fallo y cuántos intentos hubo. Así, cuando alguien dice «no me llegó», la respuesta no es una suposición.
Hay situaciones de diseño que el programa no puede resolver solo y que tampoco conviene que resuelva una IA por su cuenta. Cuando los modelos dan posturas distintas sobre un caso, el caso va a una cola: sale un mail en el momento con la postura de cada modelo y el enlace para verlo.
Queda anotado quién lo abrió, cuándo, quién lo resolvió y con qué decisión. Mientras nadie decida, sigue «sin decidir» —no hay un plazo que lo dé por aprobado—. Y resolverlo exige escribir la decisión: no se puede cerrar en blanco.
En todas las pantallas, las del alumno y las de los tutores, hay un ⚠️ Avisar un problema. Le llega a los tutores por campanita y por mail, con dónde estaba la persona y qué estaba haciendo. Cuando la pantalla no puede saberlo sola, lo pregunta: «¿En qué pantalla estabas?» y «¿Qué estabas haciendo cuando pasó?». Hay un tope de 5 avisos cada 10 minutos por persona, para que un botón trabado no inunde la campanita.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto: en qué situación aparece cada botón, qué hace y qué pasa después.
Cuando el aviso es sobre una cuenta concreta, la tarjeta la dibuja —y, si corresponde, también el ejemplo— para no tener que ir a buscarla.
El aviso dice qué mail era, cuándo se intentó y qué pasó, y agrega a quién no le llegó. El «Qué hacer» es concreto: revisar la casilla del sistema, que puede estar bloqueada; el sistema reintenta solo, y mientras tanto el resumen se puede leer en la aplicación.
El mail trae el título, el tipo, la postura de cada modelo y el enlace. Al abrirlo queda anotado quién fue el primero en abrirlo y cuándo.
Solo los tutores del alumno pueden abrir o resolver un caso. Si entra alguien que no corresponde, el intento queda registrado como rechazo.
Lo que ven los tutoresCapítulo 23 · Vigente al 16/11/2026
Cada texto que la plataforma le muestra al alumno queda guardado, palabra por palabra, con la hora, de dónde salió, qué controles pasó y —si la escribió una inteligencia artificial— qué modelo fue y cuánto costó. Si el alumno contestó algo, también queda su respuesta y cuánto tardó en darla.
Un tutor puede leer exactamente lo que su hijo o su alumno leyó. No un resumen de lo que probablemente le dijo la app: el texto.
Una plataforma que le habla a un chico con textos que a veces escribe una inteligencia artificial tiene una obligación que no es negociable: poder mostrar después qué le dijo. Si un adulto pregunta «¿qué le dijo la app cuando se equivocó?», la respuesta no puede ser una reconstrucción.
Por eso el registro no es un agregado sobre el camino normal: es el camino. Nada aparece en la pantalla del alumno sin pasar antes por el mismo lugar que lo anota. No hay una vía rápida que se saltee el registro.
| Dato | Para qué sirve |
|---|---|
| La hora | Ubicarlo en la sesión, junto a todo lo demás que pasó |
| El texto | Lo que se mostró, exacto |
| El tipo | Si fue una pregunta, una pista, una devolución, un consejo, una espera… |
| El origen | Si es un texto fijo del catálogo o lo escribió una IA |
| El número de texto (TF) | Cuando es un texto fijo, cuál del catálogo |
| El modelo | Qué inteligencia artificial lo escribió, cuando corresponde |
| Los controles | Qué revisiones pasó antes de mostrarse |
| El costo | Cuánto costó generarlo |
| La respuesta | Qué contestó el alumno, si era una pregunta |
| Cuánto tardó | Los segundos entre que lo vio y que contestó |
Todo esto el servidor ya lo guarda y lo sabe entregar, por sesión o por tipo. La pantalla dedicada para leerlo de corrido —«Lo que vio el alumno», en el menú de Informes— está dibujada y aprobada, pero todavía no construida: por eso no aparece en el menú. La regla del menú es que no se listan pantallas que no existen.
Mientras tanto, lo mismo se lee desde otros tres lugares, y no falta nada.
Y para los consejos en particular está la pantalla Consejos del tutor, donde cada consejo muestra su texto, de dónde salió, qué controles pasó, cuántas veces se dio y si sirvió —es decir, si el error no volvió en los cinco pasos siguientes—.
Solo los tutores de ese alumno. Cada pedido pasa por el control de acceso con el rol exigido, y un intento de alguien que no corresponde queda registrado como rechazo. El propio alumno no tiene esta vista: para él no existe la idea de «lo que viste», existe su ejercicio.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto.
El servidor entrega lo que vio el alumno filtrado por sesión o por tipo de texto. Es lo que usan por dentro el resumen de la sesión y el informe por fechas: no hay dos registros distintos, hay uno solo, leído de varias maneras.
Si el mismo texto vuelve a mostrarse justo después del anterior, en la pantalla del alumno reemplaza al anterior en vez de apilarse —para no llenarle la pantalla de repeticiones—, pero en el registro quedan los dos, cada uno con su hora. Lo que se simplifica es la pantalla, nunca el registro.
Algunas cosas se registran aunque el alumno no las vea como un mensaje en pantalla: las preguntas que se le hacen dentro de su propio flujo y los controles de inactividad. Quedan anotadas igual, con su tipo, para que la reconstrucción sea completa.
En el mismo bloque van también el enunciado, las fotos con lo que se leyó de cada una, qué ayudas pidió, qué contestó sobre su seguridad y qué causa estimó el programa.
El servidor lo rechaza y deja registrado el intento: quién, qué recurso y de qué alumno. No alcanza con que la pantalla no exista para esa persona; el control está en el servidor.
Lo que ven los tutoresCapítulo 24 · Vigente al 16/11/2026
Cada vez que la plataforma le pregunta algo a una inteligencia artificial, eso cuesta plata. La plataforma reserva el dinero antes de llamar, anota lo que costó aunque la llamada falle, y lo muestra: cuánto se gastó este mes, en qué, con qué proveedor, día por día y cuánto sirvió.
Hay tres topes. Dos avisan. Uno solo frena, y lo hace parando las llamadas a la IA, nunca cortándole la sesión al alumno.
| Tope | De fábrica | Qué hace |
|---|---|---|
| Por cadena | US$ 1 | Lo máximo que puede costar resolver una cosa de punta a punta. Si una cadena se pasa, se corta esa cadena |
| Por alumno y por mes | US$ 30 | Solo avisa: al 80 % y al 100 %. Nunca corta una sesión |
| De emergencia | US$ 100 | El único que frena de verdad: llegado ahí, no se llama a ninguna IA hasta que un tutor lo suba |
Con el tope de emergencia alcanzado, la pantalla de Costos lo dice arriba de todo: «Se llegó al tope de emergencia. No se llama a ninguna IA hasta que un tutor suba el tope.» Lo que no hace es dejar al alumno a mitad de un ejercicio sin explicación. Las partes que no necesitan IA siguen andando, y lo que necesita IA espera.
Ninguna llamada a una IA empieza sin antes reservar su costo estimado contra el tope de emergencia del mes. Si no entra, la llamada no se hace: la plataforma no descubre que se pasó después de gastar.
Cada reserva tiene además una clave propia: si el mismo pedido se repite —porque alguien tocó dos veces o porque un proceso se reintentó—, se reconoce la reserva que ya existe en vez de apartar la plata dos veces.
| Bloque | Qué contesta |
|---|---|
| Todas las IA juntas, todos los alumnos | El total del mes contra los topes, con enlace a cambiarlos |
| En qué se gastó | Por lo que la IA estaba haciendo, dicho en palabras, no en nombres técnicos |
| Cuánto sirvió | Cuánto fue a algo útil, cuánto a controles y cuánto se desperdició |
| Por proveedor | Cuánto a cada empresa, con qué modelos y en qué roles |
| Día por día | La curva del mes, para ver si un día se disparó |
| Cuánto cuesta cada cosa | El precio de una corrección, de una explicación, de un parecido |
| Más detalle | Lo confirmado contra lo estimado, los topes y el gasto por rol |
Hay también la proyección a fin de mes, el promedio por sesión y los tres últimos meses, y se puede bajar como CSV o como PDF.
La plataforma estima el costo de cada llamada con la lista de precios del proveedor. Después, cuando llega la factura real, se concilia: se compara lo estimado con lo facturado y se muestra la diferencia que todavía no se concilió. Son tres números distintos y se muestran los tres, porque confundirlos es la forma más fácil de creer que se gasta menos de lo que se gasta.
Si un modelo no aparece en la lista de precios del día, se usa el último precio conocido y avisa: queda un aviso en la campanita, uno por modelo y por día, para que nadie descubra tarde que un precio cambió.
Cuando conviene usar un modelo más barato para una tarea, eso no se hace solo: requiere la aprobación de un tutor. El costo puede justificar una propuesta; no puede cambiar por su cuenta con qué se le responde a un chico. Es la misma regla que atraviesa toda la plataforma: el costo nunca saca un control.
Esta parte no se lee de corrido. Es para cuando hace falta el detalle exacto.
Arriba de todo aparece el bloque de alerta. No hay un botón que lo levante desde ahí:
Subir el tope de emergencia deja además su propio rastro: es un cambio que la plataforma trata aparte, porque es el único que vuelve a habilitar el gasto.
Se libera la reserva, se anota igual el costo real, y la llamada queda registrada con su resultado. Para el alumno, una llamada fallida se ve como un texto que explica que algo no se pudo hacer y qué puede hacer mientras tanto, nunca como una pantalla rota.
Aviso en la campanita —«Un precio de IA sin verificar»—, uno por modelo y por día. Se sigue trabajando con el último precio conocido; lo que no se hace es fingir que el número es exacto.
La reserva se busca por su clave antes de apartar nada. Si ya existe una reserva viva para ese pedido, se usa esa: no se reserva dos veces y no se gasta dos veces. Es una de las cosas que las pruebas verifican con varios pedidos a la vez.
Cómo está hechoCapítulo 25 · Vigente al 16/11/2026
La plataforma no guarda una nota. Guarda, para cada habilidad —sumar fracciones de distinto denominador, elevar a un exponente negativo, sacar una raíz cúbica—, en qué punto está el alumno, en una escala de 0 a 4.
Ese número no lo decide una inteligencia artificial. Lo calcula una regla escrita en el programa, siempre la misma, a partir de lo que el alumno hizo renglón por renglón. Dos alumnos con la misma historia dan el mismo resultado.
| Estadio | Qué quiere decir | Cómo se llega |
|---|---|---|
| 0 | No hay datos, o nunca le salió | Es el punto de partida |
| 1 | Le salió una vez | Con el primer acierto |
| 2 | Le sale, pero todavía es poco | Con dos ejercicios distintos |
| 3 | Le sale solo y en ejercicios diferentes | Tres ocasiones válidas sin ayuda, al menos una limpia y una variada |
| 4 | Se acuerda días después | Con el primer repaso aprobado |
Y se sube de a un estadio por vez. Aunque un ejercicio alcance para cumplir las condiciones del 3, si estaba en 1 pasa a 2. El avance tiene que verse en el tiempo, no en un golpe de suerte.
Acá está la parte que más distingue a esta plataforma de una que cuenta aciertos. Cada renglón entra en uno de estos grupos:
Si una habilidad aparece en cuatro renglones del mismo ejercicio, eso es una sola ocasión, y se queda con el acierto más débil de los cuatro. Un chico que se equivoca en un renglón y acierta en los otros tres no acumula tres aciertos: acumula una ocasión floja.
Y una ocasión es variada solo si cambia algo más que los números. Un ejercicio igual con otros números no es una ocasión nueva en ese sentido: por eso se puede quedar trabado en el estadio 2 con la marca «falta variedad», aunque haya hecho muchos.
Bajar es más difícil que subir, y a propósito. Un estadio baja solo si se cumplen las tres condiciones a la vez:
Y aun cumpliéndose: baja un solo estadio por sesión, y nunca a 0 si alguna vez le salió. Un mal día no borra lo aprendido.
| Marca | Cuándo se pone | Qué significa |
|---|---|---|
| falta variedad | En el 2, con tres ocasiones que son todas iguales | Hizo muchos, pero todos parecidos entre sí |
| en duda | Un repaso falló y la causa no se pudo confirmar | Algo pasó, pero no se sabe qué: no baja ni cuenta como caída. Si vuelve a fallar sin causa, avisa a los adultos |
| inestable | Dos caídas reales | Sube y baja: no terminó de asentarse |
| a verificar | Cuando cae una habilidad que es previa de esta | Si se cayó lo de abajo, conviene mirar lo de arriba aunque no haya fallado |
Cuando el alumno usa bien una habilidad dentro de un problema nuevo con texto —no en un ejercicio de esa habilidad, sino en otra cosa donde hacía falta—, eso se anota como transferencia. Es la señal más fuerte de que aprendió.
Y, sin embargo, no mueve el estadio. Se cuenta aparte, y es lo que alimenta la pregunta «¿Lo usa en algo nuevo?» del informe de aprendizaje. La escala mide una cosa; la transferencia, otra. Mezclarlas haría que el número dijera menos.
El perfil es una tabla derivada: no se va editando a medida que pasan las cosas. Se guarda la historia —cada renglón evaluado, con su resultado y su camino— y el perfil se vuelve a calcular entero a partir de esa historia.
Eso tiene tres consecuencias prácticas:
Hay una pantalla aparte, en Ajustes, que no habla de ningún alumno: dice qué sabe hacer la plataforma. Es la lista de habilidades que el motor reconoce, y cada una trae su ejemplo resuelto, el parecido que el programa arma con ese ejemplo, sus errores típicos y —esto es lo importante— lo que no: qué casos todavía no sabe tratar, si hay que arreglarlo y cuándo.
La lista no está escrita a mano: la arma el propio motor cada vez, resolviendo de verdad los ejemplos. Si algo no cierra —por ejemplo, si un caso declarado como «no sabe» en realidad sí funciona—, queda registrado como aviso, y las pruebas exigen que esa lista de avisos esté vacía. Es la forma de que la documentación de lo que sabe la plataforma no pueda quedar desactualizada: la verifica el programa.
Esta parte no se lee de corrido. Son las situaciones puntuales que la regla del estadio contempla, una por una.
Queda en estadio 2 con «falta variedad», no en 3. Diez clones son diez veces la misma ocasión. Para el 3 hace falta al menos una ocasión variada —que cambie algo más que los números— y una limpia.
Cuenta como asistido: suma como acierto para pasar de 0 a 1, pero no entra entre las ocasiones válidas que hacen falta para el 3. Lo mismo si contestó «Adiviné», aunque el resultado esté bien: adivinar bien no es saber.
Preguntarle si estaba «Seguro», «Más o menos» o si «Adivinó» viene de una idea de otras materias: que un error dicho con seguridad se corrige mejor pero tiende a volver. En matemática no hay estudios fuertes. Los tres botones están para medirlo con el alumno que use la plataforma, no porque se sepa que funciona. Está en En qué se apoya.
No cuenta como ocasión nueva. Es parte del mismo ejercicio: se le dio justamente porque ese no le salía.
Queda «en duda»: no baja de estadio y no cuenta como caída. Si vuelve a fallar sin que se pueda confirmar la causa, se avisa a los adultos: dos veces sin explicación ya es algo que un adulto tiene que mirar.
Se le saca la marca «en duda», se reinicia el contador de fallos sin causa, y si estaba en 3 o más pasa a 4.
Baja un solo estadio. El segundo no vuelve a bajarlo: una sesión mala es una señal, no dos.
Las que dependen de ella quedan marcadas «a verificar» —solo si la relación de previa está bien fundada—. No se las baja: se las señala para mirar.
Si la lectura de la foto no está confirmada, o el resultado no es claramente correcto ni incorrecto, el renglón no mueve nada. Se cuenta aparte, como «no evaluable», para que después se vea cuántos hubo.
Queda anotado aparte, sin afectar a nadie. Un error real que el programa no supo clasificar no se reparte entre habilidades «parecidas»: se guarda como lo que es, un pendiente de clasificación.
Todo lo que se dedujo de esa foto deja de valer y el perfil se recalcula entero desde la historia. No hay que buscar y deshacer cambios uno por uno.
Cómo está hechoCapítulo 26 · Vigente al 16/11/2026
En esta plataforma no se borra ni se pisa nada de lo que pasó. Cada cosa que ocurre —una foto que se subió, un renglón que se evaluó, una pista que se dio, un permiso que cambió— se guarda como un hecho nuevo, con su hora. Corregir algo es agregar otro hecho, no modificar el anterior.
Todo lo demás —el perfil de habilidades, el estado de cada ejercicio, los informes— se calcula a partir de esa historia, entera, cada vez. Nada se guarda «ya resuelto».
Una plataforma que decide cosas sobre un chico tiene que poder explicar después por qué decidió lo que decidió, y tiene que poder arreglarse cuando se equivocó. Las dos cosas se vuelven casi imposibles si los datos se van pisando.
Con una historia que solo se agrega:
Borrar todas las tablas derivadas de un alumno, recalcularlas desde su historial completo y comprobar que quedan idénticas. Si esa prueba pasa, significa que no hay ningún dato que exista solo porque alguien lo escribió en su momento y nadie puede explicar de dónde salió.
Es el caso que mejor muestra cómo funciona todo. Si una foto se leyó mal y se anula, no se sale a buscar qué cosas se habían deducido de ella para deshacerlas una por una. Se agrega un hecho —«esta foto queda anulada»— y, al recalcular, todo lo que salía de esa foto deja de contar: los renglones evaluados, las evidencias, el estadio que había subido, el estado del ejercicio.
La foto anulada sigue guardada, con quién la anuló y cuándo. Lo que cambia es que deja de tener efecto.
Recalcular todo el historial en cada evento es correcto pero lento, y la lentitud se nota: al cerrar un ejercicio se disparaba un recálculo completo por cada cosa anotada, y en un ejercicio con cinco habilidades eso son treinta y cinco recálculos. Dos arreglos lo resuelven sin tocar la regla:
Esta es la forma en que la plataforma acelera: no bajando la exigencia, sino demostrando que el camino corto llega al mismo lugar.
Esta parte no se lee de corrido. Son las situaciones que el registro contempla, una por una.
El segundo no se aplica —el identificador ya existe— y queda anotado en una tabla aparte como «repetido», con su hora. Así, si algo se duplica seguido, se ve. Esto pasa de verdad: una conexión que se corta y el celular que reintenta.
Se guarda igual, con la hora en que ocurrió. Al recalcular, la historia se ordena por esa hora, así que queda en su lugar correcto y lo posterior sigue siendo posterior. La hora de llegada se guarda aparte, por si hace falta investigar.
Se rechaza con ese motivo exacto. No se crea el alumno al pasar ni se guarda el evento «suelto».
Se rechaza antes de tocar la base: todo evento necesita identificador, alumno, tipo, hora y quién lo hizo. Un hecho sin autor o sin hora no es un hecho útil.
No modifica lo que había: agrega un evento nuevo marcado como corrección del tutor. Ese sí fuerza el recálculo completo, aunque sea un simple cambio de estado, porque puede cambiar cosas que el atajo no contempla.
Además de la hora, cada evento tiene un orden propio, y el perfil se calcula con los dos. Por eso la línea de tiempo muestra milésimas: cuando dos hechos caen en el mismo segundo, el orden entre ellos puede cambiar el resultado.
Se borran sus ocho tablas derivadas en una sola operación y se vuelven a armar. Es lo que hacen las pruebas, y también lo que se puede hacer si alguna vez cambia una regla y hay que aplicarla hacia atrás.
Cómo está hechoCapítulo 27 · Vigente al 16/11/2026
Son 84 tablas en una base de datos Postgres común —nada propio de ningún proveedor—, creadas por 13 migraciones numeradas que se corren siempre en el mismo orden. Cada tabla pertenece a una de las tres clases del capítulo anterior, y eso decide qué permisos tiene la aplicación sobre ella.
Toda tabla que guarda algo de un alumno lleva su identificador, y la base tiene prendida la seguridad por filas: una persona solo puede leer las filas de los alumnos a los que tiene acceso. No es un filtro del programa; es la base la que no se las muestra.
| Grupo | Qué guarda | Algunas tablas |
|---|---|---|
| Quién es quién | Alumnos, accesos, permisos, configuración | alumno · acceso · permiso_actual · config |
| Qué se enseña | El mapa de habilidades, los errores típicos, las causas y las previas | habilidad · patron · causa · relacion_previa · fuente_previa |
| El trabajo | Tandas, ejercicios, sesiones y repasos | tanda · tanda_item · ejercicio · sesion · lote · repaso_config |
| La historia | Todo lo que pasó: eventos, fotos, renglones, pantallas mostradas | evento · captura · paso_evaluado · pantalla_mostrada |
| La IA y la plata | Llamadas, costos, reservas, tarifas y facturas | llamada_ia · costo_registro · reserva · presupuesto_mes · tarifa · factura_proveedor |
| Lo derivado | Lo calculado desde la historia | d_evidencia · d_estadio · d_ocasion · d_cambio_estadio · d_causa · d_cierre · d_freno · d_estado_ejercicio |
| Avisos e informes | Lo que se le dijo a los adultos y si llegó | aviso · aviso_adulto · entrega_aviso · mail_pendiente · caso_cola · resumen_sesion |
| La carga | Lo que se sube y lo que se recorta de cada hoja | archivo_subido · recorte · carga_ejercicio |
| Consejos y tipos de error | Los consejos del tutor y los tipos de error nuevos | consejo · caso_trampa · tipo_error_propuesto · patron_reetiquetado |
Las 13 migraciones son archivos de SQL numerados que se corren en orden y se anotan en una tabla: así la base sabe cuáles ya se aplicaron. No se edita una migración vieja; se agrega una nueva. Es la misma idea del registro, aplicada a la forma de la base.
| Migración | Qué trajo |
|---|---|
| 001 cimientos | Todo lo básico: alumnos, accesos, habilidades, tandas, sesiones, el historial, la IA y los costos |
| 002 etapa 3 | Consejos, el flujo de un ejercicio y las derivadas del perfil |
| 003 etapa 4 | Repasos, lotes y lo generado |
| 004 etapa 5 | Comparaciones en paralelo y revisiones de respuestas |
| 005 informes y avisos | Resúmenes, entregas de avisos, mails pendientes y la cola de casos |
| 006 banco | El banco de ejercicios generados |
| 007 carga | Archivos subidos, recortes y ejercicios de una carga |
| 008 a 011 | Trabajos de fondo, costo estimado, numeración única y limpieza de archivos |
| 012 consejo del tutor | Los casos trampa con los que se controla un consejo |
| 013 tipos de error | Tipos de error propuestos y reetiquetado de patrones |
Un filtro en el programa funciona hasta que alguien escribe una consulta nueva y se olvida de ponerlo. La seguridad por filas no se puede olvidar: la política está en la tabla, y se aplica aunque la consulta no la mencione. El programa puede tener un error; la base sigue sin mostrar lo que no corresponde.
Además, la regla se aplica a toda tabla que tenga alumno_id, automáticamente. Una tabla nueva que guarde algo de un alumno queda protegida por el solo hecho de tener esa columna.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
La base lo rechaza: el usuario de la aplicación no tiene ese permiso sobre esas tablas. El error aparece como lo que es, un rechazo de permisos, no como un borrado silencioso.
La consulta devuelve cero filas. No «devuelve un error de permiso»: directamente esas filas no existen para esa conexión. Es la diferencia entre ocultar y no tener.
Si tiene la columna del alumno, queda protegida por la seguridad por filas en cuanto se aplican los permisos, sin que nadie se acuerde de pedirlo. Las pruebas controlan justamente eso: que no haya ninguna tabla con alumno y sin protección.
Se agrega una migración nueva con su número. No se edita una vieja: una base que ya corrió la migración 7 tiene que llegar al mismo lugar que una nueva, corriendo las 13 en orden.
Se corren las migraciones sobre una base vacía y se vuelven a armar las tablas derivadas desde el historial. Lo único irremplazable es el historial: todo lo demás se puede volver a calcular.
Cómo está hechoCapítulo 28 · Vigente al 16/11/2026
En este capítulo, un rol es una tarea que se le pide a una IA: leer una hoja, resolver, redactar una explicación. No es el rol de una persona —alumno o tutor—, que es otra cosa y está en el capítulo siguiente.
Ninguna parte del programa le habla directo a una inteligencia artificial. Todas pasan por un único lugar —la puerta de la IA, que en el código se llama «la capa de modelos»— que hace siempre lo mismo, en el mismo orden: elige el modelo, controla qué datos puede recibir ese proveedor, exige que el pedido lleve el criterio de cómo hablarle a un chico, reserva la plata, anota la llamada antes de hacerla y registra el resultado aunque falle.
Es una puerta única. Si estuviera abierta en veinte lugares, cada uno con sus reglas, ninguna de esas garantías valdría.
Es el bloque sin el cual no se hace ninguna llamada, así que vale la pena leerlo. Son trece líneas, y van al principio de todos los pedidos, sea para leer una hoja, para resolver o para redactar una explicación:
No es un consejo para el modelo: el programa comprueba que el bloque esté antes de mandar el pedido, y si falta no manda nada.
El título de este capítulo los nombra, así que acá están los tres. Los valores son de fábrica y se cambian; el capítulo 24 cuenta cómo se miran los números y dónde se cambian.
| Tope | De fábrica | Qué hace cuando se llega |
|---|---|---|
| Por cadena | US$ 1 | Lo máximo que puede costar resolver una cosa de punta a punta —leer una hoja, corregirla y explicarla es una cadena—. Si se pasa, se corta esa cadena, no las demás |
| Por alumno y por mes | US$ 30 | Solo avisa, al 80 % y al 100 %. No corta nada: no se le corta la sesión a un chico por plata |
| De emergencia | US$ 100 | El único que frena de verdad. Llegado ahí no se llama a ninguna IA hasta que un adulto lo suba. Lo que no necesita IA sigue andando |
| Proveedor | Con datos del alumno | Sin datos del alumno |
|---|---|---|
| Anthropic | Permitido — es la base de todo | Permitido |
| OpenAI | Bloqueado en el código, aunque el permiso diga que sí | Permitido — segunda mirada |
| No se usa | No se usa | |
| DeepSeek | Bloqueado | Bloqueado |
El filtro que saca la identidad mira el texto: el nombre, el mail, el identificador. Pero en una foto de una hoja escrita a mano puede estar el nombre del chico escrito arriba, y eso el filtro de texto no lo ve.
Por eso el código bloquea a OpenAI para cualquier dato de alumno, incluso si la tabla de permisos dice «permitido». La segunda mirada sobre material del alumno la hace otro modelo de Anthropic. Es un límite puesto donde no se puede desactivar por configuración.
Cada rol es una tarea concreta con su propio texto de pedido, su modelo, su límite de tokens y su tiempo de espera. Agrupados:
| Para qué | Roles |
|---|---|
| Leer la hoja | separador · lector · segundo lector · ingesta |
| Resolver | resolutor A · resolutor B · resolutor C · árbitro |
| Evaluar lo que escribió | evaluador · segundo evaluador · intérprete de causa · intérprete de simplificaciones |
| Hablarle al alumno | tutor · revisor de mensajes · consejero · revisor de consejos · resumidor |
| Armar ejercicios | generador · controlador · resolutor de parecidos · revisor de parecidos |
| Casos trampa y tipos de error | autor y revisor de casos trampa · casos trampa · proponedor, revisor y clasificador de tipos de error |
Hay una pieza que hace su trabajo en la misma cadena y no es un rol de IA, por eso no está en la tabla de arriba: el verificador. En matemática, quien decide es él.
Se nota un patrón en quién hace qué: cuando algo tiene que ser revisado, el revisor es de otra empresa que el autor. El resolutor de parecidos es de Anthropic y su revisor, de OpenAI; el consejero es de Anthropic y su revisor, de OpenAI. Dos modelos de la misma familia tienden a equivocarse igual.
Hay una regla que manda sobre todas las esperas: el alumno nunca espera más de 90 segundos desde que manda su trabajo hasta ver una respuesta, sumando respaldos y reintentos.
Cuando empieza algo que lo tiene esperando, se abre un plazo. Cada llamada dentro de ese plazo espera como mucho lo que queda, aunque su propio límite sea más largo. Y si ya no queda tiempo, ni se hace: sale directamente como «no contestó a tiempo» y se sigue por el camino previsto para cuando una IA falla. Es mejor una salida clara a los 90 segundos que una respuesta perfecta a los tres minutos.
Tres roles tienen un modelo de respaldo, que se usa una sola vez si la llamada vence o falla la conexión: el lector, el evaluador y el intérprete de simplificaciones. Son los tres que están en el camino crítico de un alumno esperando.
Si OpenAI queda sin saldo, sin permiso o caído, la plataforma lo detecta por la forma del error, sigue trabajando solo con Anthropic y avisa a los tutores que la verificación doble quedó en pausa. Un error de límite por minuto no cuenta: ese se reintenta como siempre.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
No se hace la llamada. Es una verificación sobre el texto del pedido antes de salir, no una convención que alguien pueda olvidar.
Se rechaza. Esto salió de un caso real: el 4 de noviembre el separador recibió «Separá los ejercicios de esta hoja» sin ninguna imagen —era un PDF hecho en computadora— y se inventó 14 ejercicios. Desde entonces, los cuatro roles que leen una hoja nunca se llaman sin la imagen.
Se usa otro y queda anotado. No se cancela el trabajo por eso, pero tampoco se manda a donde no corresponde en silencio.
Se registra igual, con su costo. Cada rol tiene un máximo de tokens pensado para su tarea: el generador llegó a 6000 porque con 3000 las respuestas de un ejercicio de ocho pasos llegaban cortadas. Que el límite sea el adecuado se descubre probando con ejercicios reales, no estimando.
La reserva se busca por su clave. Si ya existe una viva, se usa esa: no se reserva ni se cobra dos veces.
No se llama. Dejar pasar una llamada sin registro sería dejar pasar un gasto sin rastro y una respuesta sin explicación.
Se le carga su precio de fábrica sin tocar los de los demás. Sin eso, su costo quedaría en cero y el gasto del mes diría menos de lo real.
Queda marcado como no disponible y no se elige más; sigue en el catálogo solo para poder leer las llamadas viejas que lo usaron. Pasó con uno el 31 de octubre: el proveedor empezó a contestar «no encontrado».
Se sigue con Anthropic solo, y un aviso explica a los tutores que la verificación doble quedó en pausa y qué hacer para volver a tenerla. Los ejercicios entran igual.
Cómo está hechoCapítulo 29 · Vigente al 16/11/2026
Acá hay datos de menores de edad: sus fotos, lo que escribe, en qué se equivoca. La plataforma está armada partiendo de eso. Solo entra quien está en una lista, cada uno entra con su cuenta de Google, la base no le muestra a nadie las filas de un alumno que no le corresponde, y todos los días se hace una copia cifrada que cada tres meses se prueba restaurando de verdad.
No hay contraseñas en la plataforma. El botón «Entrar con Google» lleva a Google, Google devuelve el mail ya verificado, y el sistema se fija si ese mail está en la lista de accesos. Si está, queda la sesión iniciada con una cookie que la página no puede leer. Si no está, no entra y el intento queda registrado con el mail, la hora y el motivo.
No guardar contraseñas es, además de más cómodo, una cosa menos que se puede filtrar.
Y debajo de las tres, la cuarta, que no depende del programa: la seguridad por filas de la base. Aunque una consulta se olvidara de filtrar, la base no devuelve filas de un alumno al que esa persona no tiene acceso.
Que un botón no aparezca en la pantalla no es seguridad. Cada operación se verifica en el servidor, y un intento que no corresponde se rechaza y queda registrado: quién, qué quiso hacer, de qué alumno y por qué se rechazó.
La pantalla oculta cosas para no confundir; el servidor las impide.
Todos los días, de madrugada, hora de Buenos Aires:
| Qué se copia | Cómo |
|---|---|
| La base completa | Cada tabla en JSON, cifrada |
| Las fotos nuevas | A un almacén acumulativo, con un manifiesto que lista cada foto y su huella |
| El recetario y «Si Claude no está» | Cifrados, junto con lo demás |
La rotación conserva una copia si tiene menos de 14 días, o si es la primera de su semana y tiene 91 días o menos, o si es la primera de su mes. El almacén de fotos nunca se rota: las fotos se acumulan.
Si una copia falla, sale un mail a todos los adultos a cargo. Y los lunes, si la semana anterior salió todo bien, sale un solo mail que lo dice. Esa segunda parte importa tanto como la primera: sin ella, nadie se entera de que hace tres semanas que el aviso de falla tampoco llega.
Cada tres meses se crea una tarea: prueba de restaurar. Toma una copia diaria, una semanal y una mensual, espera la aprobación de un tutor, y una vez aprobada restaura en una base aparte y registra el resultado.
Una copia que nunca se probó no es una copia: es un archivo del que se supone algo. La prueba trimestral convierte la suposición en un hecho verificado, con fecha.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
No entra, y el intento queda en «Intentos que no entraron» de Accesos, con el mail, el motivo —no está en la lista— y la hora.
Mismo camino, con el motivo «acceso vencido». La fecha de fin se controla al entrar, no se confía en que alguien se acuerde de quitar el acceso.
Sus sesiones abiertas se cierran. No sigue adentro hasta que cierre el navegador.
El servidor lo rechaza, lo registra como intento rechazado, y la base tampoco le habría devuelto las filas. Son dos barreras independientes, y las pruebas verifican las dos por separado.
El servidor contesta que no y la pantalla muestra «Esta pantalla es de los tutores». El menú de los adultos ni siquiera se dibuja para él: sus pantallas no pasan por ahí.
Mail a todos los adultos a cargo esa misma noche. La copia siguiente se intenta igual: una falla no desarma la rutina.
La tarea queda esperando la aprobación de un tutor. No se restaura nada sin que alguien lo apruebe, porque es una operación que mueve datos; pero tampoco se saltea: queda pendiente hasta que se decide.
Hasta que esté aprobado, el desarrollo usa dos alumnos inventados. Las fotos reales y las copias de la base nunca van al repositorio.
Cómo está hechoCapítulo 30 · Vigente al 16/11/2026
Un chico que espera 40 segundos mirando una pantalla quieta se va. Por eso la velocidad acá no es una mejora: es parte de que la plataforma funcione. La meta es 5 segundos por espera, 10 como máximo, y nunca más de 90 segundos entre que manda su trabajo y ve algo.
Todo se consigue de una sola manera: haciendo las cosas antes, no haciéndolas peor.
Esta es la regla que hace que preparar de antemano no cambie nada de lo pedagógico. Todo lo preparado queda guardado en el registro, no en la pantalla del alumno. Lo ve recién cuando toca el botón, exactamente igual que antes. Un ejemplo resuelto preparado hace dos días se muestra en el mismo momento en que se habría mostrado si se armara ahí mismo.
Y se usa solo si se armó con exactamente los mismos datos: cada preparado guarda una huella de lo que se le pidió a la IA. Si algo cambió, se descarta y se pide de nuevo. Es preferible esperar a usar algo que ya no corresponde.
Si toca el botón y lo preparado todavía se está armando, la plataforma espera a que termine en vez de pedirlo de nuevo. Suena contraintuitivo, pero está medido: el 31 de octubre, el ejemplo resuelto tardaba 35 a 40 segundos; al cortar a los 25 y empezar otro, el segundo tardaba 33 más. Pedirlo de nuevo siempre tarda más que esperar lo que ya viene en camino.
Y si no hay nada preparado, todo sigue por el camino de antes: se arma en el momento. El preparado es una ventaja cuando está, no un requisito.
Cuando el alumno toca «Empezar», la sesión se arma solo con lo que ya está listo. Si para un ejercicio que no le salió todavía no hay un parecido armado, o falta un ejercicio de contraste, ya no se le pide a la IA en ese momento —eso trababa la base y lo dejaba esperando la llamada entera—: se arma de fondo y entra en su sesión como el ejercicio siguiente, mientras él ya está trabajando.
Cuesta lo mismo: es la misma llamada, más tarde. Los adultos, en «Armar sesión», siguen como antes, porque ahí sí hay alguien que puede esperar unos segundos a cambio de ver la sesión completa.
Toda espera de más de 10 segundos queda anotada. Si en un día se juntan tres, llega un aviso a la campanita de los tutores —uno por día—. La lentitud no se descubre porque alguien se queje: se mide y avisa sola.
Dos ejemplos de cosas que se arreglaron así:
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
Aparece al instante. Es el caso normal cuando la tanda se cargó con tiempo.
Se espera —hasta dos minutos— a que termine, en vez de empezar otro. Mientras tanto, la pantalla dice que está preparando algo, no se queda muda.
Si cambió algo de lo que se le había pedido a la IA, la huella no coincide y se descarta. Se pide de nuevo con los datos actuales.
Una espera de respuesta abierta más de 5 minutos se da por perdida. Así una caída no deja al alumno en una pantalla de espera eterna.
Aviso a la campanita de los tutores, uno por día. No uno por espera: eso sería ruido, y el ruido se deja de leer.
Entra igual. El parecido se arma de fondo y, cuando está y pasó sus controles, entra en su sesión como el ejercicio siguiente.
Cada ejercicio se prepara para su alumno —los ejercicios no se comparten entre alumnos— y cada uno va en su propia cadena, con el tope de un dólar. La tanda muestra «Preparando… (3 de 7)» y el tutor puede irse.
Cómo está hechoCapítulo 31 · Vigente al 16/11/2026
Todo viaja junto en un solo paquete —en la jerga se llama «imagen», que acá no tiene nada que ver con una foto—: el servidor y las pantallas, construidos a la vez y publicados a la vez, así nunca queda una mitad nueva con otra vieja. Corre en Render, con una base Postgres y un disco para las fotos y las copias. La dirección es loaprendi.com.
Y una regla sobre todas: nada se publica solo. La publicación automática está apagada a propósito; una versión sube cuando un tutor dice «sí, publicar».
| Pieza | Qué es |
|---|---|
| El servidor | Python con FastAPI. Toda la lógica, las reglas y la puerta de la IA |
| Las pantallas | Next.js y React. Se compilan dentro de la misma imagen |
| La base | Postgres común, esquema propio, 84 tablas, 13 migraciones |
| El disco | 5 GB en Render para las fotos y las copias cifradas |
| Entrar | Google, con la lista de accesos |
| Los mails | Salen desde la dirección de avisos del dominio |
Las claves —de Anthropic, de OpenAI, del mail, de Google, de la base y de cifrado de copias— se cargan a mano en Render. Ninguna está en el archivo de configuración ni en el repositorio; el archivo solo dice qué claves hacen falta.
Pasó de verdad, el 4 de noviembre. El servidor sigue contestando «no estoy listo», con el motivo corto —sin mostrar el SQL—, y reintenta cada 30 segundos. A los 15 minutos Render cancela la versión nueva, y la anterior sigue atendiendo: nadie queda afuera.
Cada migración corre en su propia transacción, así que no puede quedar a medias. Se mira el registro, se arregla el archivo y se publica de nuevo.
En la mayoría de los casos, volver atrás es publicar la versión anterior: casi ningún cambio toca la forma de la base. Para los que sí, la regla que lo hace posible es la del capítulo 25: el historial solo se agrega. Volver atrás nunca significa recuperar algo borrado, porque no se borró.
Hay además una herramienta para rehacer una evaluación sobre fotos ya evaluadas: muestra primero qué cambiaría, y solo con una opción explícita lo guarda —como una evaluación nueva, sin borrar la anterior—. Volver atrás de eso es no haberlo guardado.
Hay un documento en el repositorio escrito para una sola situación: que alguien tenga que hacerse cargo de todo esto sin Claude. Dice dónde está cada cosa, cómo se prueba en una computadora, cómo se arranca el servidor, cómo está armada la base, dónde vive cada regla, cómo se publica y cómo se vuelve atrás. Su primera línea aclara el supuesto: «un programador con Python y Postgres alcanza».
Se actualiza cada vez que cambia cómo se arma, se publica o se vuelve atrás. Es la contracara de este documento: este explica qué hace la plataforma; aquel, cómo se la mantiene.
Hay un modo de pruebas que arranca con los dos alumnos inventados, una tanda de ejemplo y una IA de demostración que no llama a nadie. Alcanza con Python y un Postgres local, y hay una dirección de entrada que solo existe en ese modo: en producción no existe.
Para la matemática y las pantallas hay dos conjuntos de pruebas más: las de aceptación, que corren contra el servidor, y la comparación visual, que saca capturas del prototipo y del código y arma una hoja lado a lado.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
No pasa nada en producción. La publicación automática está apagada: subir y publicar son dos actos distintos.
Hay una regla de forma para toda migración, y al arrancar el servidor avisa si un archivo no la cumple. Además hay una prueba que lo controla en cada batería: el error se encuentra antes de publicar, no durante.
Al publicar no hay ningún paso a mano. Volver atrás es publicar la versión anterior.
Se carga solo al arrancar, sin pisar lo que ya está en la base. No hace falta migración ni ningún paso a mano.
Los trabajos de fondo están en una tabla: se puede consultar cuáles quedaron pendientes y de qué tipo. El documento «Si Claude no está» trae la consulta exacta.
Se corre la herramienta desde la consola de Render. Primero muestra qué cambiaría —una llamada al evaluador por foto— y recién con una opción explícita lo guarda, como evaluación nueva.
Para trabajarCapítulo 32 · Vigente al 16/11/2026
Todas las pantallas se arman igual, y eso no es una preferencia estética: una pantalla previsible es una pantalla que no hay que aprender. Hay un solo lugar donde están definidos los colores, los tamaños y las medidas; cada pantalla los usa.
Y hay una regla de proceso que pesa más que cualquier detalle visual: un cambio de diseño se dibuja primero en el prototipo, Ale lo aprueba ahí, y recién después se pasa al código.
| Orden | Parte | Cómo es |
|---|---|---|
| 1 | El menú | El mismo en todas |
| 2 | La cabecera | Título, quién la ve y, a la derecha, la pastilla con las iniciales y el nombre completo del alumno. En el celular, la pastilla baja debajo del título |
| 3 | Pasos numerados | Solo si la tarea tiene pasos. El actual, lleno; los hechos, en verde; los que faltan, en gris |
| 4 | Una línea de ayuda | Qué se hace en esta pantalla, en una o dos frases |
| 5 | Bloques | El contenido agrupado por tema, cada uno con título y un color suave. Dos columnas en la PC cuando entran; una en el celular |
| 6 | Una sola acción principal | Abajo a la derecha, con el color de acento |
| Color del bloque | Qué contiene |
|---|---|
| Naranja | Lo que pide una decisión |
| Azul | Información |
| Violeta | Lo que ve el alumno: lo que la plataforma le muestra a él, para que el adulto lo distinga de lo suyo |
| Verde | Lo que salió bien |
| Gris | El detalle |
Y hay un segundo juego de colores, el de los números de una tanda, que se repite igual en la tarjeta del alumno y en la del adulto. Cada número tiene su color y la barra de abajo los muestra en proporción:
| Número | Color | Qué cuenta |
|---|---|---|
| Salieron bien | Verde | Resueltos y confirmados |
| A medias | Naranja | Empezados y sin terminar; se retoman |
| Sin hacer | Gris | Todavía no se abrieron |
| No salió, cerrado | Rojo apagado | No salió y se cerró; más adelante entra un parecido |
| Total | Sin color | Todos los de la tanda |
Las dos pantallas donde aparecen —«Tandas abiertas» y la tarjeta del alumno— tienen al pie un «¿Qué significa cada color?» que repite esta misma tabla, para no tener que recordarla.
Pero el color nunca es la única señal: un interruptor dice «Sí» o «No» además de ponerse verde, y un estado trae su nombre escrito además de su color. Quien no distingue colores lee exactamente la misma información.
Comparten los colores pero no la estructura. No tienen menú, no tienen campanita, no tienen filtros. Tienen letra más grande, botones más altos, un ancho de contenido más angosto y su propio color de acento. Un ejercicio ocupa la pantalla entero.
Y hay cosas que simplemente no existen ahí: notas, cronómetro, informes, perfil, costos, configuración. No están escondidas detrás de un permiso: esas pantallas no existen para él.
Todos los colores, tipografías, tamaños, altos de botón y radios de borde están definidos en un único archivo. Ninguna pantalla define un color propio.
Eso hace posible algo que de otro modo sería interminable: el modo oscuro. Está resuelto en ese mismo archivo, cambiando los valores; ninguna pantalla tuvo que adaptarse.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
La lista crece hacia abajo. Nunca se agrega una columna ni una barra horizontal: en un celular, lo que está a la derecha no existe.
Es uno de los casos que hay que probar antes de aprobar una pantalla, junto con un ejercicio largo, una espera larga y una foto rechazada. Son los cuatro que rompen un diseño que solo se probó con datos cómodos.
Las pantallas cambian solas, porque los colores salen todos del mismo lugar. No hay una versión oscura aparte que mantener.
Primero en el prototipo, con la aprobación de Ale, y después en el archivo de colores. Nunca directamente en una pantalla: un color suelto en un archivo es el principio de dos estilos distintos.
Pasó: con la campanita abierta y muchos avisos, la barra fija quedaba más alta que la pantalla y tapaba todo lo de abajo. Se arregló haciendo que, con la campanita abierta, la barra deje de ser fija. Es el tipo de cosa que aparece solo al probar con datos reales.
Se usa el estilo general y se deja anotado. No se inventa un estilo nuevo para esa pantalla sola.
Para trabajarCapítulo 33 · Vigente al 16/11/2026
Casi todo lo que el alumno lee no lo escribe una inteligencia artificial: sale de un catálogo de textos fijos, cada uno con su número. Son más de 160, y cada uno fue escrito, discutido y aprobado una vez.
Lo que sí escribe una IA —una devolución, una pista, un consejo— pasa antes por controles de código que miden lo que se puede medir sin opinar, y recién después por un revisor.
Un texto escrito en el momento, dentro del código de una pantalla, tiene tres problemas: nadie lo revisó, no se puede cambiar sin tocar el programa, y no hay manera de saber cuántos textos distintos recibe un chico ni qué tono tienen entre todos.
Con un catálogo numerado, en cambio: cada texto se puede nombrar en una conversación («el TF-14»), se revisan todos juntos, y cuando uno se muestra queda registrado con su número, así que después se sabe exactamente cuál fue.
Los textos del catálogo tienen una voz. Algunos ejemplos reales:
Lo que tienen en común: hablan de lo que pasó y de lo que sigue, nunca de lo que el chico es. Un problema técnico es «no puedo revisar», no «hubo un error». Una pausa no es una falta. Y ninguno dice «muy bien» ni «excelente».
Cuando hace falta un texto nuevo, se escribe y se marca como propuesto, esperando la aprobación de Ale. En las capturas del prototipo se ve así: «TF-96 (propuesto)». No se cuela un texto nuevo a la pantalla de un chico sin que alguien lo haya leído.
Antes del revisor —que es otra IA—, el código mira lo que se puede medir sin opinión:
Si algo falla, el texto no se muestra y queda guardado como no mostrado. Nunca se muestra «lo mejor que salió».
Hay además un conjunto de reglas para que una cuenta se vea en todos lados como se escribe en papel: la raíz cúbica como ∛, la raíz cuadrada como √, el por como ·, la división como :, el menos como el menos largo —no el guion— y los exponentes arriba, en superíndice.
Esto importa más de lo que parece. Un chico que escribió (3/2)⁴ en su hoja y lee (3/2)^4 en la pantalla tiene que hacer una traducción mental que no tiene nada que ver con lo que está aprendiendo. Las mismas reglas se usan en los mails y en los avisos, porque la cuenta tiene que verse igual en todas partes.
| Catálogo | Qué guarda |
|---|---|
| Textos fijos | Más de 160 textos numerados, todo lo que lee el alumno |
| Patrones y causas | Los errores típicos, con su detector, y las causas posibles de cada uno, con la frase que se le ofrece al alumno para elegir |
| Parámetros | 101 valores configurables, cada uno con nombre, grupo, valor de fábrica, en qué niveles se puede cambiar y su ayuda de cuatro preguntas |
| Modelos | Qué modelo usa cada rol, con qué proveedor, su precio, sus límites y su respaldo |
| Conocimientos | Lo que sabe y lo que no sabe hacer el programa, para la pantalla «Qué sabe el programa» |
| Textos de los roles | El pedido de cada rol de IA, todos empezando por el «Criterio del joven» |
Todos se cargan solos al arrancar, sin pisar lo que ya está en la base. Agregar un error típico nuevo o un parámetro nuevo no requiere ninguna migración ni ningún paso a mano al publicar.
Esta parte no se lee de corrido. Son las situaciones puntuales, una por una.
El control busca el resultado en todas sus formas equivalentes, no solo tal como está escrito. Si el resultado es 3/4 y la pista dice «0,75» o «tres cuartos», se rechaza igual.
No se muestra igual. El control del código va antes del revisor y no se puede sobreescribir con una aprobación.
Se arregla, no se rechaza. Se parte en dos renglones y se muestra.
No se muestra y queda guardado como no mostrado, con el motivo. Así se puede ver después qué quiso decir la IA y por qué se frenó, sin que el alumno lo haya leído nunca.
Se escribe, se le da número y se marca como propuesto hasta que Ale lo aprueba. Se ve así en el prototipo antes de existir en la pantalla.
Se carga solo al arrancar, sin pisar lo que ya estaba. Nada que hacer a mano al publicar.
Para trabajarCapítulo 34 · Vigente al 16/11/2026
El trabajo sobre la plataforma se organiza en colas. Una cola junta pedidos —cosas que no andan, cosas que faltan—, los ordena, y los va cerrando en lotes que se publican juntos. Cada lote lleva su control antes y después de publicar.
Este capítulo cuenta cómo funciona ese mecanismo y qué hay programado hoy. A medida que algo se termina, sale de acá y entra en su capítulo: deja de ser un trabajo programado y pasa a ser cómo funciona la plataforma.
Las pruebas viven aparte del código y las escribe otro equipo. No se modifican para que pasen. Si una prueba parece equivocada, se anota como una decisión pendiente y se discute; no se la edita para que deje de molestar.
Desde la v7, además, las pruebas nuevas las escribe un revisor independiente que lee solo la especificación y el prototipo, nunca el código. Una prueba escrita mirando el código prueba que el código hace lo que hace.
El criterio no es cuánto cuesta cada cosa, sino a quién afecta y cómo:
| Prioridad | Qué entra |
|---|---|
| 1 | Lo que traba al alumno o lo deja esperando |
| 2 | Lo que le da información equivocada |
| 3 | Lo que les falta a los tutores |
| 4 | Lo nuevo |
| 5 | Estética |
| 6 | Lo que mejora las condiciones pero nadie nota |
Y hay una medición honesta de las estimaciones: se anota cuánto se estimó y cuánto tardó de verdad. Hasta ahora, las estimaciones salieron largas —una tarea estimada en 2 h 30 tardó 1 h 10; otra de 3 h tardó 1 h—. Eso se dice en el tablero, para que quien lee las próximas estimaciones sepa cómo leerlas.
Al 15 de noviembre, la cola abierta es la del 09/11, con unas 32 horas de trabajo pendientes. En orden:
| Qué | De qué se trata |
|---|---|
| Tope para armar parecidos | Que el armado de un parecido corte y avise en vez de colgarse. Programado, sin publicar; con decisiones pendientes |
| El Inicio de los adultos, el fondo | Hace 350 consultas por carga, cinco por cada ejercicio de cada tanda abierta: de ahí los 5,4 segundos. El arreglo es traerlas juntas |
| Los parecidos y la lección no salen | Once causas distintas en ejercicios largos con raíces y potencias. La tarea más larga de la cola |
| El cálculo pesado, afuera | Que preparar una tanda nunca trabe al alumno, que un trabajo cancelado quede cancelado de verdad, y la alarma por falta de crédito |
| La hoja bien resuelta en rojo | Un enunciado mal leído hacía que una hoja correcta saliera con renglones marcados mal |
| La foto de un solo renglón | Corregir un renglón y sacarle la foto solo a eso |
| Tres fallas al cargar | Un signo que el programa no entiende, dos formas de escribir lo mismo tomadas como distintas, y un cartel falso de «no coincide» |
| El casillero de repaso vacío | Que un repaso en blanco quiera decir «ese repaso no se hace» |
| Entrar en menos de 2 segundos | Lo que quedó de hacer que el alumno entre rápido |
| Dictar con el micrófono | Escribir hablando, en los tres lugares donde hace falta |
| El adulto confirma el resultado | Para los ejercicios que entran sin freno |
| Protección por filas en 31 tablas | Las que todavía no la tienen. Prioridad baja pero no opcional: antes hace falta una copia de prueba y una noche sin alumnos |
Y varias más de informes, costos y estética. El detalle completo, con su estado exacto, vive en el tablero de la cola.
Porque un documento que solo cuenta lo que ya funciona miente por omisión. Quien lo lee para decidir algo necesita saber también qué se sabe que falta, y que está anotado y ordenado, no olvidado.
Y porque el camino de ida y vuelta es parte del método: un pedido entra acá, y cuando se termina y se controla sale de acá y se escribe en su capítulo. Si algo se terminó y este capítulo todavía lo lista, el documento está atrasado; si algo está en un capítulo y no funciona, el documento está mintiendo. Las dos cosas se pueden comprobar.
Esta parte no se lee de corrido. Son las situaciones puntuales del método de trabajo.
Se arregla y hay otra vuelta. El control deja escrito qué bloqueaba y qué quedó pendiente. Una tarea puede necesitar tres vueltas, y eso se anota.
No se toca. Se anota en las decisiones pendientes del equipo de pruebas y se discute. Las pruebas son el contrato: si se las edita para que pasen, dejan de serlo.
Se frena esa parte, se escribe el bloque «Decisión para Ale» y se suma a la lista de decisiones pendientes. No se adivina una regla.
No se aplica. Se avisa qué se perdería y se espera. Las reglas que no se tocan están escritas y no se negocian tarea por tarea.
Hay un mecanismo explícito de decisiones por delegación: cuando Ale lo autoriza, se decide y se escribe qué se decidió y por qué, y él puede cambiar cualquiera después. Lo que no se hace es esperar sin avanzar ni avanzar sin dejar rastro.
La versión anterior sigue atendiendo. Se mira el registro, se arregla y se publica de nuevo. Pasó el 4 de noviembre con una migración.
Sale de este capítulo y se escribe en el suyo. Para eso hay una comprobación mecánica: dado un cambio, qué capítulos hay que actualizar. Si un archivo cambiado no tiene capítulo asignado, la comprobación falla.
Para trabajarCapítulo 35 · Vigente al 16/11/2026
Las decisiones finas de esta plataforma —cuántos segundos, qué pasa si falla, qué se muestra y qué no— no están todas juntas en una tabla. Están dentro del capítulo del módulo al que pertenecen, contadas como funciona la plataforma, porque es ahí donde sirven.
Este capítulo es lo otro: el control. La forma de comprobar que el documento está completo y al día, sin tener que leerlo entero y confiar en el criterio de alguien.
Una decisión suelta en una tabla gigante —«D31-37: toda espera de más de 10 segundos se anota»— no le sirve a nadie. Quien lee quiere entender cómo funciona la velocidad, y ahí esa decisión es una frase del capítulo 29. Quien busca esa decisión puntual la encuentra buscando «10 segundos».
La lista separada tiene además un problema peor: es el lugar donde las cosas se desactualizan. Si una decisión se revisa y el capítulo se corrige pero la tabla no, quedan dos versiones y gana la equivocada.
Hay un inventario, armado leyendo el código, de todo lo que el documento tiene que cubrir. Cada pieza tiene su tipo, su archivo, el capítulo que la explica y su estado.
| Tipo de pieza | Cuántas | Qué es |
|---|---|---|
| Archivos del servidor | 94 | Cada archivo de programa del servidor. No son «los módulos» del capítulo 1, que son las cinco partes de la plataforma |
| Pantallas | 33 | Cada pantalla de la aplicación |
| Botones | 306 | Cada botón y cada campo de cada pantalla |
| Componentes | 27 | Las piezas que se repiten entre pantallas |
| Rutas | 101 | Cada camino por el que la pantalla le pide algo al servidor |
| Tablas | 84 | Las de la base |
| Parámetros | 101 | Los valores configurables |
| Textos | 162 | El catálogo de lo que lee el alumno |
| Catálogos | 5 | Patrones, parámetros, modelos, conocimientos, roles |
| Total: 913 piezas | ||
Esto convierte «¿el documento está completo?» de una opinión en un número. No dice que lo escrito esté bien escrito —eso lo decide quien lee—, pero sí dice qué no está escrito, y eso antes no se sabía.
El problema de fondo nunca fue escribir el documento: fue que se desactualiza. Y se desactualizaba porque nadie era dueño del paso de pasar un cambio del código al documento, y porque nada impedía dar por terminado un trabajo sin haberlo hecho.
La solución es una comprobación: dados los archivos que cambiaron, qué capítulos hay que actualizar. Se le puede dar un cambio puntual o una versión entera, y responde la lista. Y si un archivo cambiado no tiene capítulo asignado, la comprobación falla.
Porque invierte la carga. Antes había que acordarse de actualizar el documento; ahora hay que decidir explícitamente no hacerlo, y esa decisión queda a la vista.
Y porque un archivo nuevo sin capítulo no puede pasar desapercibido: la comprobación lo marca. Un módulo nuevo no documentado deja de ser un olvido silencioso y pasa a ser algo que alguien tuvo que saltear.
Aparte del documento, cada decisión deja su rastro en el lugar donde se tomó:
Este documento no reemplaza nada de eso: lo lee y lo cuenta en forma de cómo funciona la plataforma.
Esta parte no se lee de corrido.
Se le pasan los archivos que cambiaron a la comprobación y devuelve qué capítulos tocar. No hay que acordarse ni adivinar.
La comprobación falla, porque ese archivo no tiene capítulo. Hay que decidir en cuál va. Esa es exactamente la intención.
La respuesta es un número: cuántas de las 913 piezas tienen capítulo escrito. Y la lista de las que faltan, por tipo.
Se busca por lo que dice, no por su número: «10 segundos», «tope de emergencia», «falta variedad». El número interno de una decisión no aparece en el texto corrido justamente para que el documento se pueda leer; pero la decisión está, contada.
Se corrige el capítulo donde está contada —no hay una segunda copia que se pueda olvidar— y queda el rastro en la bitácora y en las decisiones de la cola, con las dos fechas.
Para trabajarCapítulo 36 · Vigente al 16/11/2026
Hay más de 2.300 pruebas automáticas que corren enteras antes de cada publicación. Pero lo que realmente formó esta plataforma no fueron las pruebas: fueron los casos reales, cosas que pasaron de verdad con un chico usándola, y que cambiaron cómo funciona algo.
Este capítulo junta unos cuantos, porque explican mejor que cualquier principio por qué la plataforma es como es.
| Grupo | Qué comprueba |
|---|---|
| Aislamiento | Que los dos alumnos inventados no se mezclen nunca, en ninguna tabla |
| Eventos repetidos o fuera de orden | Que el mismo hecho dos veces no cuente dos veces, y que uno que llega tarde quede en su lugar |
| Concurrencia en el gasto | Que dos pedidos a la vez no reserven ni gasten dos veces |
| Reconstrucción | Que borrar las tablas derivadas y rearmarlas desde el historial dé exactamente lo mismo |
| Comparación visual | Que cada pantalla nueva o cambiada coincida con el prototipo aprobado |
| Protección de datos | Que una persona no pueda leer filas de un alumno que no le corresponde |
Hay además un grupo que corre aparte y gasta plata de verdad: las pruebas con la IA real. Se corren cuando hace falta comprobar algo que una IA simulada no puede mostrar, con un gasto aprobado de antemano, y dejan registrada cada llamada con su costo.
4 de noviembre. Se le pidió a la IA «Separá los ejercicios de esta hoja» sin mandarle la imagen —era un PDF hecho en computadora, no una foto— y se inventó 14 ejercicios que no existían.
Qué cambió: los cuatro roles que leen una hoja no se pueden llamar sin la imagen. Es una verificación, no una advertencia.
13 de noviembre. En una hoja decía 2 + 3·4, con el punto de multiplicar. La aplicación lo leyó como el decimal 3,4 y corrigió el ejercicio con el número equivocado.
Qué cambió: ahora la plataforma distingue el punto de multiplicar de la coma decimal y, cuando duda, pregunta al cargar —con la pregunta dibujada y aprobada en el prototipo antes de existir—.
13 de noviembre. Un renglón quedó marcado en rojo con «acá está el error» y, debajo, el mismo cierre decía «Este ejercicio está bien» y «Cada renglón es igual al anterior».
Qué cambió: el cierre tiene que decir una sola cosa. O «se corrigió solo», o tratar ese número como una anotación al margen; nunca las dos a la vez.
13 de noviembre. Un toque doble en «💪 Seguro» mandó dos pedidos; el segundo cerró la espera del primero mientras se armaba la corrección, y la pantalla quedaba trabada hasta recargar.
Qué cambió: cada respuesta cierra solo su propia espera, un segundo toque no hace nada, y la espera se abre antes de confirmar.
15 de noviembre. 154, 116, 102, 75 y 51 segundos. La causa: el programa rehacía todo el diagnóstico del alumno con cada anotación —una por cada renglón correcto y por cada habilidad—.
Qué cambió: el diagnóstico se rehace una sola vez al final del cierre. Medido: de 5.037 a 19 idas y vueltas a la base con 5.000 anotaciones; de 19,4 segundos a 0,5. Y se comprobó en las dos direcciones que las ocho tablas calculadas quedan idénticas.
15 de noviembre. La pantalla quedaba en «Cargando…» sin fin. Medido: 5,4 segundos con el servidor en calma, más de 45 mientras corría una lectura de foto. La causa de fondo: 350 consultas por carga, cinco por cada ejercicio de cada tanda abierta.
Qué cambió: por ahora, que la pantalla se dibuje igual y el resumen se cargue aparte con un tope de 12 segundos. El arreglo de fondo —traer las consultas juntas— está en la cola.
15 de noviembre, prueba con IA real. En una foto, dos ejercicios quedaron mal leídos, y las dos lectoras independientes perdieron exactamente lo mismo. La segunda mirada no sirvió: los dos modelos se equivocaron igual.
Qué cambió: nada en el código, porque lo que atajó el error fue algo que ya existía: la confirmación del adulto antes de darle la tanda al alumno. Es el caso que muestra para qué está ese paso.
15 de noviembre. Se corrigió a mano el estado de un ejercicio en la base. Tres minutos después, la base volvía a decir lo de antes.
Por qué: las tablas derivadas se rearman desde los eventos. Corregir una tabla derivada a mano no corrige nada, porque no es ahí donde vive la verdad. Para cambiar algo hay que agregar un hecho.
4 de noviembre. Una migración falló al publicar. El servidor siguió contestando «no estoy listo», Render canceló la versión nueva a los 15 minutos y la anterior siguió atendiendo.
Qué confirmó: que la forma de publicar está bien armada. Nadie quedó afuera, y el error apareció en el registro con su motivo.
5 de noviembre. Un ejercicio tenía 4⁶ : 2¹⁴. El pizarrón, con el tope de exponente subido, lo resolvía calculando 4096 y 16384 y dividiendo. Así no se enseña, y además el chico se había equivocado justamente en la propiedad de las potencias de igual base, que era lo que el ejercicio practicaba.
Qué cambió: el pizarrón usa las propiedades cuando corresponde, con su regla explicada en cada renglón: se restan los exponentes, una base que es potencia de otra, el exponente negativo. Y nunca las aplica en una suma.
Ninguno se encontró leyendo el código. Todos aparecieron con alguien usando la plataforma, casi todos con un chico de verdad haciendo su tarea. Y casi ninguno era un error de programación en el sentido clásico: eran supuestos equivocados sobre cómo iban a pasar las cosas.
Que se corriera un PDF sin imagen. Que alguien tocara dos veces un botón. Que una hoja tuviera un punto de multiplicar. Que dos modelos distintos se equivocaran igual. Que un chico corrigiera un solo renglón y le sacara la foto a eso.
Por eso el método incluye probar con los casos incómodos —un ejercicio larguísimo, nombres largos, una espera larga, una foto rechazada—, correr pruebas con la IA real aunque cuesten plata, y mirar la plataforma andando después de cada publicación. Las pruebas automáticas impiden que algo que ya funcionaba se rompa. Los casos reales son los que enseñan qué tiene que funcionar.