Here’s a universal truth: Within minutes of a solution going live, the user base finds unexpected ways of using it. This is applicable across the board, from large-scale ERP implementations to websites, from graphic design software to video games.
Often, these novel ways of interaction are more efficient, more effective or just more fun than the standard processes that we spent months developing and testing for.
What starts as an unintended glitch or bug can sometimes become a cherished quirk embraced by both developers and users alike.
The most famous examples are in video games, where unintended mechanics can sometimes lead to the most innovative and enduring gameplay elements.
However, the lessons learned extend beyond the gaming sector and offer valuable lessons about user experience, system design, and the critical importance of understanding how users interact with software.
Gaming Gives Us Some of The More Famous Accidental Innovations
Businesses often encounter this when deploying internal or customer-facing systems. Most of these go unreported but can lead to significant development and remediation costs. Rest assured, though, I’ll cover a couple later.
However, the world of video games provides some of the most famous and striking—and indeed, the most fun—examples of this phenomenon.
The Streetfighter II Bug That Changed The Whole Genre
Arguably, the most influential is the combo system in Street Fighter II. Now a staple of fighting games, this mechanism allows users to chain multiple moves together to unleash devastating attacks on their opponent—but it wasn’t designed this way.
During the development of Street Fighter II, the team noticed a bug that allowed players to cancel the animation of one move into another if timed correctly.
This cancellation created a brief window where another attack could be launched without the opponent being able to block or counter.
Fortunately, the developers chose not to fix this bug, which ended up defining not only Street Fighter II but the entire fighting game genre.
Space Invaders From Bug to Icon Feature
Another great case of a bug becoming a defining feature is with Spacer Invaders, another of the all-time classic video games.
If you have ever played Space Invaders, as I did when younger, you know that the more alien ships you destroy, the faster the remaining ships move and the harder they are to hit. In researching this article I found that this behaviour was also the result of bug.
The alien space ships were supposed to travel at a consistent, uniform speed throughout the entire level!
However, the more alien ships you destroyed, the less work the CPU had to do to draw them. These unused CPU cycles led to the alien ships moving very fast.
Quake Users Found a Novel Way to Use an Exiting Feature
It’s not just coding glitches, though. We see examples like “rocket jumping” in first-person shooters like Quake, where players use the explosive force of their own weapons to propel themselves to great heights.
What started as a physics quirk became a staple technique, adding depth and excitement to gameplay.
When you combine this type of unforeseen user behaviour with exploitable bugs, you can start to run into real issues.
But Unexpected User Behaviour Isn’t All Fun and Games
Of course, as illustrative as these examples are, they are relatively trivial and didn’t damage businesses or reputations.
But could this same inquisitive user behaviour unlock access-protected data and super-user credentials, or something even more problematic?
In a word, yes. It’s well known that most data breaches involve internal actors, i.e. employees. You never know who will find and exploit even the smallest of glitches.
SQL Injections Are A Powerful Example of User Exploits
Getting into the dark side of things, we have SQL injections. This code injection technique involves inserting malicious SQL statements into application fields expecting simple text.
They can allow attackers to bypass authentication to access, modify and even delete sensitive information.
In the business world, and with customer-facing solutions, these are probably the most well-known examples of unforeseen user behaviour leading to unexpected results. They are one of the most primitive but highly effective vulnerabilities.
The Sony Pictures 2011 SQL incident is a well-known example that allowed bad actors to get hold of the passwords, email addresses, home addresses and other details of over 1 million users.
Sometimes, It Can Be As Simple As Changing One Digit in a URL
The First American Financial Corp Data Leak in 2019 was a significant security incident involving one of the largest title insurance companies in the United States.
In May of that year, a design flaw in First American’s website exposed approximately 885 million sensitive customer records.
Ben Shoval, a real estate developer in Washington state, discovered the vulnerability.
He found that once he had legitimately accessed a secure document, he could access other agents’ documents—which included sensitive personal and financial data—by simply changing a single digit in the URL.
What Do These Examples Teach Us About User Behaviour?
These examples teach us valuable lessons about user experience and system design. The biggest takeaway for me is this:
Uusers will always find creative ways to exploit a system—or work around a bug—which often reveals underlying desires or needs that developers and testers didn’t initially consider.
Innovative companies must pay attention to these behaviours and incorporate them into updates. The more you change your software, the higher your chances of introducing exploitable glitches.
Users Will Find The Smallest Loophole
Your solution might be rock solid, but users are tricky customers.
They use the system so much and share their experiences with each other that it is highly likely that they will quickly find and exploit even the tiniest opportunity.
Take the Streetfighter II combo bug mentioned above. This was a one-frame window, a fraction of a second, but the game players quickly found it.
The Importance of Comprehensive Testing
While the gaming examples highlight the potential benefits of unexpected behaviours, they also underscore the critical importance of thorough testing in software development.
Comprehensive testing isn’t just about identifying and eliminating bugs; it’s about understanding how users interact with the system.
Traditional testing methodologies often focus on ensuring that software functions as intended under normal conditions. However, our examples demonstrate that users frequently use software in ways that developers never anticipated.
This reality calls for a more holistic approach to testing, one that includes:
- User behaviour analysis: Observing how real users interact with the software in controlled and uncontrolled environments.
- Edge case testing: Exploring what happens when users push the boundaries of the system’s intended use.
- Long-term usage studies: Understanding how user behaviour evolves as they become more familiar with the software.
- Community feedback loops: Establishing channels for users to report unexpected behaviours and their opinions.
However, while fixing critical bugs that impact functionality or security is crucial, there’s also value in occasionally embracing the quirky and unexpected…
A Certain Serendipitous Charm
I don’t want to leave this on a negative note, so here’s another of my favourite examples of a gaming glitch that became a cherished feature.
An integer underflow in the original Civilization game transformed Gandhi from a pacificist into a highly aggressive leader. The developers found this so amusing that they intentionally kept Gandhi’s high aggression as an inside joke in later games.
I’m not saying you want to deliberately sabotage your solutions, but sometimes unexpected features can become part of a product’s charm and identity.
They remind us that behind every piece of software are real people – developers who make mistakes and users who adapt, create, and find joy in unexpected places.
Conclusion: Embrace and Understand User Behaviour
Glitches becoming features highlights the unpredictable nature of software development and human interaction—users will find novel and unexpected ways to use any system,
This underscores the importance of comprehensive testing beyond mere functionality checks to understand genuine user behaviour.
It’s no good just running through your happy paths; you need to mess around with the system and react to how actual users are doing things.
By embracing this approach, developers can create more robust, user-friendly software that meets and exceeds user expectations, often in unexpected ways.
Sometimes, the most exciting innovations come not from careful planning but from embracing the unexpected and understanding how users truly interact with our creations.
