Jakob Nielsen is a thinker I admire. He’s dubbed the usability guru for a reason: his contributions to the field of user experience are immense. Most notably, he is the author of the widely cited 10 usability heuristics which interaction designers use to build better products the world over.
In his most recent video titled, “Time to Make Tech Work,” he makes an impassioned argument: Users waste an inordinate amount of time debugging, which both confuses them and stifles their confidence. He advocates for a revolution in which users stand up and demand that programmers fix bugs before moving on to yet more superfluous features.
Jakob’s argument has me of two minds.
On the one hand, I agree that bugs can muddle users’ mental models. For instance, on an e-commerce site, a user initially expects that product links go to product pages. But wait! After clicking on one the site presents them with a cryptic 404 ‘page not found’ error instead. Perhaps this bug stems from a broken call to an inventory database.
The user doesn’t know this though. How could we expect them to?
After the error, their understanding of the system gets hazy because it is uncertain where a product link will take them. As a result, the user’s sense of control, confidence, and clarity in using the site plummets.
Maybe this predicament could have been avoided: follow Jakob’s 9th heuristic and make 404 pages that enable the user to recognize, diagnose, and recover from the issue. Alas, as is too often the case, the product team designed no such error message.
Ultimately, I agree with Jakob that teams should more consistently implement his error heuristic and aim to avoid bugs in the first place.
On the other hand, the overarching argument implied by Jakob is problematic: It’s time to make tech work because currently — it doesn’t. After all, there are a whopping 10 billion hours ‘wasted’ on debugging each year.1
However, we need to interpret those hours in context. The Nielsen Company (no relation to Jakob) has shown that American adults spend on average 10 hours a day engaging with technology. Aggregated over a year, we find that US adults alone spend roughly 730 billion hours using devices each year. In other words, only 1% of the time people use technology they are debugging, which means about 99% of the time technology works.
Based on this analysis, Jakob seems confused. It’s not that technology doesn’t work; quite the contrary, it’s astonishing the consistency with which it does work. His denial of this fact makes his ‘tech doesn’t work’ argument seem like a hasty generalization at best.
Building on his critique Jakob makes a bold series of claims in an indignant tone:
“All the world’s programmers should do no other work the next two years than fixing bugs. New features will do the world much less good than getting the existing features implemented correctly so that they work every time, without fail.”
The problem with this argument is that it wrongly assumes fixing bugs unanimously provides more benefit to the user experience than adding features. It doesn’t. Many bugs, especially in obscure parts of an app, are encountered so rarely that the utility of fixing them is marginal at best. Whereas certain features, if added, can be a boon.
For example, take a new GPS feature that points vulnerable members of the population to where they can access vaccinations. That add-on may provide value to thousands, maybe even millions of people — a good for the world we’d never realize if all programmers did was fix bugs.
Based on this assessment, Jakob’s proposal comes across as a glib rallying cry largely devoid of the nuance you would expect from a thinker of his stature.
Granted, he was probably being tongue in cheek. However, even if we modify his claim such that it concerns the vast majority of programmers rather than all — it’s still a weak argument. There are simply too many factors to consider, such as industry, user type, and the distribution of error severity, to make such a sweeping claim.
In the end, some UX practitioners might interpret his arguments in a fairly literal manner because he’s a thought leader in their space. Indeed, he should be a leader — Jakob’s usability heuristics are a perennial source of insight — however, some of his more emphatic claims are worth raising an eyebrow to.
Endnote
1 Jakob takes the 10 billion hours wasted and divides it by the number of hours in the average person’s life. The result? Errors cost us 23,000 lifetimes annually, more than the number of people killed by sharks and tornados each year.
While his math is clever, I take issue with it on two points. First, the number of people killed by sharks and tornados is relatively low, so being greater than that number isn’t saying much. Second, there’s a far-fetched analogy that’s implied: dying by shark or tornado is like a lifetime wasted debugging. Surely, there’s a difference. Death by a natural disaster is a tragedy; debugging is an inconvenience. Granted, errors annoy users but to insinuate that they are a catastrophe is a stretch.