En 2010 Carmen Reinhart y Kenneth Rogoff publicaron un artículo que se convirtió en uno de los más influyentes de la crisis financiera. La tesis: superado un umbral de deuda pública en torno al 90% del PIB, el crecimiento medio se desploma. Se citó en debates parlamentarios y en la justificación de políticas de austeridad en media Europa.
En 2013 un estudiante de doctorado de la Universidad de Massachusetts, Thomas Herndon, pidió la hoja de cálculo original para replicar el análisis como ejercicio de curso. Entre los errores que encontró, junto a decisiones discutibles de ponderación, había uno trivial: una fórmula de media cuyo rango de celdas seleccionado dejaba fuera a cinco países. Corregidos los problemas, el desplome desaparecía.
No era un error de programación. Era un error de arrastre de ratón.
El no-code no es nuevo
La promesa de hacer programar a quien no es programador tiene al menos sesenta años, y cada generación ha creído ser la primera.
El COBOL, en 1959, se presentó como un lenguaje lo bastante cercano al inglés como para que los directivos pudieran leer y escribir programas. En los años ochenta los llamados lenguajes de cuarta generación iban a hacer innecesaria la programación tradicional. Luego llegaron las herramientas CASE, después el desarrollo rápido de aplicaciones, después las plataformas low-code, y ahora el no-code.
En 1978 Edsger Dijkstra escribió una nota breve y despiadada sobre la idea de programar en lenguaje natural. Su argumento no era esnobismo: era que la dificultad de programar no está en la sintaxis sino en la precisión exigida, y que un lenguaje ambiguo no elimina la necesidad de precisión, la esconde hasta que es demasiado tarde.
En 1987 Fred Brooks formalizó la misma idea en el ensayo más citado de la ingeniería del software. Distingue entre complejidad accidental —la de las herramientas, las sintaxis, la infraestructura— y complejidad esencial, que es la dificultad de especificar exactamente qué debe ocurrir en todos los casos posibles. Las herramientas atacan la primera. La segunda se queda donde está.
El no-code es, en esta lectura, un excelente ataque a la complejidad accidental. Lo cual es mucho, y no es todo.
El mayor experimento natural: la hoja de cálculo
El verdadero precedente del no-code no es una plataforma de automatización. Es Excel, que es el lenguaje de programación más usado del mundo y casi nunca se llama así.
En 2005 Christopher Scaffidi, Mary Shaw y Brad Myers intentaron contar, partiendo de los datos del censo laboral estadounidense, cuánta gente programa sin ser programadora. La estimación proyectada a 2012 era de más de 55 millones de personas usando hojas de cálculo y bases de datos en el trabajo, frente a menos de 3 millones de programadores profesionales. Una proporción de veinte a uno.
Y aquí llega el dato que debería hacer pensar a cualquiera que esté a punto de automatizar un proceso de empresa con una herramienta visual. Raymond Panko recopiló durante años las auditorías independientes sobre hojas de cálculo reales usadas en producción por empresas reales. El resultado agregado: errores encontrados en aproximadamente el 88% de las hojas examinadas, con tasas de error por celda del orden del 1-5%.
No son hojas hechas por aficionados. Son las hojas sobre las que se toman decisiones.
Los casos célebres son la punta del iceberg: además de Reinhart y Rogoff, el informe interno de JPMorgan sobre las pérdidas de 2012 documenta que un modelo de riesgo usaba una hoja de cálculo en la que los valores se copiaban y pegaban a mano entre celdas, y en la que una división había sido sustituida por una suma.
El no-code no elimina la programación. La traslada a personas sin control de versiones, sin pruebas, sin revisión por pares y sin ningún momento en que a alguien se le pida comprobar.
Dónde funciona de verdad
Dicho todo esto, el no-code funciona, y conviene ser preciso sobre dónde.
| Característica de la tarea | No-code | Código |
|---|---|---|
| Regla simple y estable (“cuando llegue X, haz Y”) | Excelente | Excesivo |
| Pocos casos particulares | Excelente | Excesivo |
| Muchas excepciones y condiciones anidadas | Se vuelve ilegible | Mejor |
| Hace falta rastrear quién cambió qué | Débil | Mejor |
| Volumen alto y consecuencias económicas directas | Arriesgado | Mejor |
La regla práctica que se deriva es simple: el no-code destaca cuando la complejidad esencial del problema es baja. Cuando es alta, no la hace desaparecer: solo la vuelve más difícil de ver, porque un diagrama de veinte bloques conectados no se lee como se lee un texto.
Antes de automatizar: cuatro comprobaciones
- Mide antes de automatizar. Durante una semana anota cuántas veces haces cada operación repetitiva y cuánto dura. Automatizar algo que haces dos veces al mes es un pasatiempo, no una ganancia.
- Automatiza un proceso que ya hayas escrito. Si no sabes describir con palabras todos los casos, excepciones incluidas, la herramienta no los gestionará por ti.
- Diseña el fallo, no solo el éxito. ¿Qué pasa si el campo está vacío, si el servicio no responde, si el dato llega dos veces? Ahí es donde el 90% de las automatizaciones caseras falla en silencio.
- Pon una notificación en cada fallo. Una automatización que se rompe sin avisar es peor que la operación manual que sustituyó, porque nadie se entera durante meses.
- Escribe qué hace, dónde y quién la construyó. Un documento de diez líneas. Es la diferencia entre una herramienta de empresa y una deuda que estalla cuando cambias de trabajo.
- No metas datos que no deben salir de la empresa. Las plataformas de automatización pasan los datos por servicios de terceros: hay que consultarlo antes con quien lleva la seguridad.
- Aprende de todos modos algo de lógica de programación. Condiciones, bucles, variables. Son los mismos conceptos bajo cualquier interfaz visual, y tenerlos claros es lo que separa una automatización robusta de una frágil: ver cómo aprender a programar.
Lo que pienso: el no-code se vende con la promesa equivocada
Creo que el no-code es una de las cosas más útiles que le han pasado al trabajo de oficina en los últimos diez años, y que se vende con la promesa equivocada. La promesa correcta no es “ya no tienes que pensar como un programador”. Es “puedes pensar como un programador sin tener que aprender además la infraestructura”, que ya es mucho.
También creo que el 88% de Panko merece más atención de la que recibe, porque describe exactamente el aspecto que tendrán las automatizaciones no-code corporativas dentro de unos años: miles de flujos construidos por personas distintas, nunca documentados, nunca revisados, que nadie se atreve a apagar porque nadie sabe qué pasa si lo hace.
Una predicción mía, sin números que la respalden: la competencia que contará no será saber usar una plataforma de automatización, sino saber reconocer cuándo un proceso tiene demasiadas excepciones para ser automatizado por nadie.
Preguntas frecuentes
¿El no-code sustituirá a los programadores? No pasó con el COBOL, ni con los lenguajes de cuarta generación, ni con las herramientas CASE. El argumento de Brooks explica por qué: las herramientas reducen la complejidad accidental, no la esencial.
¿Qué herramientas conviene aprender? Menos importante de lo que parece. El concepto de disparador, condición y acción es común a todas; aprendido en una, se transfiere. Mejor una usada bien que cinco probadas.
¿Por dónde empiezo? Por la operación más aburrida y más frecuente que haces, no por la más complicada. La primera automatización sirve para entender la herramienta, no para resolver el problema grande.
¿Es arriesgado para los datos de la empresa? Puede serlo, porque los datos transitan por servicios externos. Hay que verificarlo antes con quien lleva la seguridad informática, no después.
¿Excel cuenta como no-code? Es el no-code original y más extendido, y es también del que más datos de errores tenemos. Las bases están en funciones esenciales de Excel.
Fuentes
- Herndon, T., Ash, M., y Pollin, R. (2014). Does High Public Debt Consistently Stifle Economic Growth? A Critique of Reinhart and Rogoff. Cambridge Journal of Economics, 38(2), 257-279. El rango de celdas incompleto.
- Panko, R. R. (1998). What We Know About Spreadsheet Errors. Journal of End User Computing, 10(2), 15-21. Las auditorías de campo y la proporción de hojas con errores.
- Panko, R. R., y Halverson, R. P. (1996). Spreadsheets on Trial: A Survey of Research on Spreadsheet Risks. HICSS-29.
- Scaffidi, C., Shaw, M., y Myers, B. (2005). Estimating the Numbers of End Users and End User Programmers. IEEE VL/HCC. La estimación de los 55 millones.
- Brooks, F. P. (1987). No Silver Bullet: Essence and Accidents of Software Engineering. IEEE Computer, 20(4), 10-19. Complejidad esencial y accidental.
- Dijkstra, E. W. (1978). On the Foolishness of “Natural Language Programming”. EWD667.
- Ko, A. J., et al. (2011). The State of the Art in End-User Software Engineering. ACM Computing Surveys, 43(3), 1-44.
- Nardi, B. A. (1993). A Small Matter of Programming: Perspectives on End User Computing. MIT Press. No hay dirección pública estable disponible para el texto completo. Por qué las hojas de cálculo triunfaron donde otras herramientas fracasaron.
- JPMorgan Chase (2013). Report of the Management Task Force Regarding 2012 CIO Losses. La descripción del modelo basado en copiar y pegar manual entre celdas.
- Powell, S. G., Baker, K. R., y Lawson, B. (2008). A Critical Review of the Literature on Spreadsheet Errors. Decision Support Systems, 46(1), 128-138.
Este artículo se ha escrito siguiendo el proceso descrito en cómo escribimos. Si encuentras un dato mal reportado, escríbeme: lo corrijo y lo señalo al final del artículo.



