In 2010 Carmen Reinhart and Kenneth Rogoff published a paper that became one of the most influential of the financial crisis. The claim: above a public-debt threshold of around 90% of GDP, average growth collapses. It was cited in parliamentary debates and in the justifications for austerity policies across half of Europe.
In 2013 a doctoral student at the University of Massachusetts, Thomas Herndon, asked for the original spreadsheet to replicate the analysis as a course exercise. Among the errors he found, alongside debatable weighting choices, was a trivial one: an averaging formula whose selected cell range left out five countries. With the problems corrected, the collapse disappeared.
It wasn’t a programming error. It was a mouse-drag error.
No-code isn’t new
The promise of letting non-programmers program is at least sixty years old, and every generation has believed it was the first.
COBOL, in 1959, was presented as a language close enough to English that managers could read and write programs. In the 1980s so-called fourth-generation languages were going to make traditional programming unnecessary. Then came CASE tools, then rapid application development, then low-code platforms, and now no-code.
In 1978 Edsger Dijkstra wrote a short, unkind note on the idea of programming in natural language. His argument wasn’t snobbery: it was that the difficulty of programming lies not in syntax but in the precision required, and that an ambiguous language doesn’t remove the need for precision, it hides it until it’s too late.
In 1987 Fred Brooks formalised the same idea in the most-cited essay in software engineering. He distinguishes accidental complexity (of tools, syntaxes, infrastructure) from essential complexity, which is the difficulty of specifying exactly what must happen in every possible case. Tools attack the first. The second stays where it is.
No-code is, on this reading, an excellent attack on accidental complexity. Which is a lot, and isn’t everything.
The biggest natural experiment: the spreadsheet
The real precedent for no-code isn’t an automation platform. It’s Excel, which is the most widely used programming language in the world and is almost never called one.
In 2005 Christopher Scaffidi, Mary Shaw and Brad Myers tried to count, starting from US labour census data, how many people program without being programmers. The estimate projected to 2012 was over 55 million people using spreadsheets and databases at work, against fewer than 3 million professional programmers. A ratio of twenty to one.
And here comes the figure that should give pause to anyone about to automate a business process with a visual tool. Raymond Panko collected, over years, the independent audits of real spreadsheets used in production by real companies. The aggregate result: errors found in roughly 88% of the spreadsheets examined, with per-cell error rates on the order of 1-5%.
These aren’t spreadsheets built by amateurs. These are the spreadsheets decisions are made on.
The famous cases are the tip of the iceberg: besides Reinhart and Rogoff, JPMorgan’s internal report on its 2012 losses documents that a risk model relied on a spreadsheet in which values were copied and pasted by hand between cells, and in which a division had been replaced by a sum.
No-code doesn’t eliminate programming. It moves it onto people with no version control, no tests, no peer review and no moment at which anyone is asked to check.
Where it genuinely works
All that said, no-code works, and it’s worth being precise about where.
| Task characteristic | No-code | Code |
|---|---|---|
| Simple, stable rule (“when X arrives, do Y”) | Excellent | Overkill |
| Few special cases | Excellent | Overkill |
| Many exceptions and nested conditions | Becomes unreadable | Better |
| Need to track who changed what | Weak | Better |
| High volume with direct financial consequences | Risky | Better |
The practical rule that follows is simple: no-code excels when the essential complexity of the problem is low. When it’s high, no-code doesn’t make it go away. It just makes it harder to see, because a diagram of twenty connected blocks can’t be read the way text can.
Before you automate: four checks
- Measure before automating. For one week, log how often you do each repetitive operation and how long it takes. Automating something you do twice a month is a hobby, not a gain.
- Automate a process you have already written down. If you can’t describe every case in words, exceptions included, the tool won’t handle them for you.
- Design the failure, not just the success. What happens if the field is empty, the service is unreachable, the record arrives twice? That’s where 90% of homemade automations fail silently.
- Put a notification on every failure. An automation that breaks without telling anyone is worse than the manual step it replaced, because nobody notices for months.
- Write down what it does, where, and who built it. A ten-line document. That’s the difference between a company tool and a debt that detonates when you change jobs.
- Don’t put data in that shouldn’t leave the company. Automation platforms pass data through third-party services: check with whoever handles security first.
- Learn some programming logic anyway. Conditions, loops, variables. They’re the same concepts under any visual interface, and having them clear is what separates a robust automation from a fragile one: see how to learn to code.
My take: no-code is sold with the wrong promise
I think no-code is one of the most useful things to happen to office work in the last decade, and that it’s sold on the wrong promise. The right promise isn’t “you no longer have to think like a programmer”. It’s “you can think like a programmer without also having to learn the infrastructure”, which is already a lot.
I also think Panko’s 88% deserves more attention than it gets, because it describes exactly what corporate no-code automation will look like in a few years: thousands of flows built by different people, never documented, never reviewed, that nobody dares switch off because nobody knows what happens if they do.
A prediction of mine, with no numbers behind it: the skill that will matter won’t be knowing an automation platform, it will be recognising when a process has too many exceptions to be automated by anyone.
Frequently asked questions
Will no-code replace programmers? It didn’t happen with COBOL, fourth-generation languages or CASE tools. Brooks’s argument explains why: tools reduce accidental complexity, not essential complexity.
Which tools should I learn? Less important than it seems. The concept of trigger, condition and action is common to all of them; learned on one, it transfers. Better one used well than five tried out.
Where do I start? With the most boring, most frequent operation you do, not the most complicated one. The first automation is for understanding the tool, not for solving the big problem.
Is it risky for company data? It can be, because data passes through external services. Check with whoever handles information security first, not after.
Does Excel count as no-code? It’s the original and most widespread no-code, and it’s also the one we have the most error data on. The basics are in essential Excel functions.
Sources
- Herndon, T., Ash, M., & 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. The incomplete cell range.
- Panko, R. R. (1998). What We Know About Spreadsheet Errors. Journal of End User Computing, 10(2), 15-21. The field audits and the share of spreadsheets with errors.
- Panko, R. R., & Halverson, R. P. (1996). Spreadsheets on Trial: A Survey of Research on Spreadsheet Risks. HICSS-29.
- Scaffidi, C., Shaw, M., & Myers, B. (2005). Estimating the Numbers of End Users and End User Programmers. IEEE VL/HCC. The 55 million estimate.
- Brooks, F. P. (1987). No Silver Bullet: Essence and Accidents of Software Engineering. IEEE Computer, 20(4), 10-19. Essential and accidental complexity.
- 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 stable public address available for the full text. Why spreadsheets succeeded where other tools failed.
- JPMorgan Chase (2013). Report of the Management Task Force Regarding 2012 CIO Losses. The description of the model based on manual copy-paste between cells.
- Powell, S. G., Baker, K. R., & Lawson, B. (2008). A Critical Review of the Literature on Spreadsheet Errors. Decision Support Systems, 46(1), 128-138.
This article was written following the process described in how we write. If you find a figure reported wrongly, write to me: I’ll correct it and note the correction at the bottom of the article.



