TL;DR: Most users will never fully learn your system, read your documentation, or internalize your intended workflow. They will instead discover whatever path minimizes friction, uncertainty and cognitive effort. These unofficial workflows – the software equivalent of desire paths across a lawn – are not evidence of user failure but direct feedback about how the system actually wants to be used. Good UX design is therefore less about teaching users a “correct” mental model and more about aligning the product with natural human behavior before unofficial workarounds emerge.
The Imaginary User
Software design often begins with an imaginary person who behaves far more patiently and methodically than any real human being ever will. This imagined user reads labels carefully, studies onboarding flows, notices subtle visual distinctions, explores menus intentionally, and gradually constructs a mental model of the application over time. If they become confused, they consult documentation or watch tutorials before proceeding further.
The Imaginary Users and Actual Users put in a Venn diagram looks like this:
O O
In reality, people approach software with a narrow and immediate objective. They want to send the message, export the report, edit the image, submit the form, or complete the purchase with as little interruption as possible. The software itself is rarely the thing they care about. It is simply an obstacle standing between them and the task they are actually trying to complete.
This difference completely changes how UX should be approached.
Many systems are designed around the assumption that users will eventually “learn the product” if sufficient onboarding material is provided. When friction appears, the instinctive response is to add explanation: more tooltips, more guided tours, more tutorials, more contextual help, more videos, more onboarding sequences. Modern applications increasingly resemble interactive manuals wrapped around ordinary functionality. They manage to simultaneously underestimate and overestimate the user, insulting both ends of the deal.
One of the harshest but most practical assumptions in UX design is therefore this:
Assume the user will never read anything unless failing to do so immediately blocks progress.
And the logical extension of it is:
Assume the user will never read anything unless failing to do so immediately blocks progress, and that the subsequent action is 732 random clicks on a screen, closing and reopening the application and possible physical consequences to the keyboard, mouse or touchscreen.
This is not a cynical view of users. It is a realistic view of human behavior. Reading instructions carries cognitive overhead, and people instinctively avoid unnecessary cognitive expense whenever experimentation appears cheaper. If randomly clicking around produces results faster than studying the interface, people will click around. If search works more reliably than navigating menus, navigation effectively stops existing in the user’s mental model. And if the person lived through the era when hitting a device with a hammer (which can be anything, as per Adam Savage) actually made a difference, there exists no process to unlearn that.
The implication is uncomfortable because it means many UX problems are not educational failures at all. They are alignment failures. The software is attempting to impose a structure that conflicts with natural human behavior, and users respond by either quietly routing around it or abandoning the product.
Desire Paths in Software
“If you are a User, then everything you’ve done has been according to a plan.“
— Tron (Tron, 1982)
Urban planners have a useful term for the unofficial trails that appear when people repeatedly ignore the paved sidewalk and walk across the grass instead: desire paths.
These paths emerge because human beings are extremely efficient at identifying friction and bypassing it. The official route may be aesthetically pleasing or logically structured, but if it requires unnecessary effort, people gradually carve out an alternative that better matches their instincts. Over time, the dirt trail becomes a more honest map of human behavior than the original design ever was.
Software systems develop these same patterns constantly.
Every sufficiently large product accumulates unofficial workflows that users discover independently:
- People exporting data into spreadsheets because the application’s built-in tools feel restrictive
- Users relying entirely on search instead of browsing navigation trees
- Teams maintaining internal “how to survive this software” documents
- Copy-paste routines replacing official integrations
- Screenshots replacing bookmarking systems
- Browser history functioning as primary navigation
These are often some of the most valuable UX feedback available.
When large numbers of users independently converge on the same workaround, they are collectively communicating something important about the structure of the product itself. They are revealing where the system’s conceptual model diverges from the users’ actual goals.
Analytics dashboards can show where users clicked, but they do not necessarily explain what users were attempting to accomplish. A repeated workaround, however, contains meaning.
These unofficial paths emerge from observed behavior rather than self-reported behavior. Users may describe themselves as methodical and deliberate, but their actions usually reveal a much simpler pattern: they continuously optimize for reduced effort, reduced uncertainty, and preserved momentum.
The grass rarely lies.
The Failure of Instruction-Based UX
A surprising amount of modern UX design still operates on the assumption that friction can be solved primarily through explanation. When users struggle, teams respond by layering instructional systems on top of the existing product rather than reconsidering the underlying interaction model itself.
This approach works in genuinely specialized environments. Professional tools such as Illustrator, Maya or AutoCAD involve inherently complex tasks, and users expect a learning curve in exchange for powerful capabilities. The complexity originates from the domain itself rather than from unnecessary interaction friction. You can’t create desire paths through a labyrinth.
Consumer software increasingly adopts the same posture… but without the same justification.
Applications that perform relatively ordinary tasks now frequently introduce onboarding sequences, hidden gestures, layered menus, modal workflows, progressive disclosure systems, and tutorial overlays that users must mentally unpack before basic functionality becomes obvious or even available.
The problem with this model is that modern software exists within an intensely competitive environment where even small amounts of friction carry enormous cost. Users are constantly comparing applications not against theoretical capability but against the least demanding experience they have encountered elsewhere. Every unnecessary pause, hidden interaction, or forced learning step increases the probability that the user simply disengages. For me, personally, if you have to click on seven different points on the screen just to be able to tap on the first button in the UI, this often becomes the “uninstall and try the next alternative” moment.
This explains why products that feel obvious often outperform products that are theoretically more sophisticated. Reducing friction produces compounding benefits because it preserves flow. The user continues moving forward without interruption, without context switching into interpretation mode, and without needing to construct an elaborate mental model simply to proceed.
Good UX tends to feel strangely unremarkable. The interface does not announce itself constantly because it is aligned closely enough with instinctive behavior that the user barely notices the interaction layer at all. There is no dramatic onboarding moment because the system does not require one.
The experience simply begins.
Designing for Human Behavior Instead of Against It
Once UX is viewed through the lens of desire paths, the role of design changes significantly. The goal is no longer to enforce idealized workflows through explanation and restriction. The goal becomes shaping the environment so that the desired behavior naturally emerges as the path of least resistance.
Well-designed systems quietly reduce the amount of interpretation users must perform. They minimize hidden state, avoid unnecessary mode switching, support partial understanding, preserve momentum, and make recovery from mistakes straightforward. Instead of assuming users will internalize a complex conceptual framework, they accommodate the reality that most people operate opportunistically and incrementally.
This is why some of the most successful interaction patterns feel almost deceptively simple:
- Search replacing rigid navigation structures
- Autosave replacing explicit save workflows
- Inline editing replacing dedicated edit modals or modes
- Forgiving parsers replacing strict syntax requirements
- Direct manipulation replacing layers of configuration
These approaches all share the same philosophy. Rather than demanding that users conform to the architecture of the system, the system bends itself toward existing human tendencies wherever possible.
One of the clearest examples of this dynamic is the enduring existence of spreadsheets across workflows that should have nothing to do with spreadsheets. They remain enormously popular not because they are elegant pieces of software design, but because they respond immediately to user intent. They allow arbitrary structure, experimentation, direct manipulation, and visible state with very little ceremony. Users often prefer wrestling with formulas over navigating a heavily constrained enterprise workflow.
Every CSV Export button in a product quietly acknowledges this reality.
These software desire paths are evidence that human beings are extraordinarily efficient at locating unnecessary friction. When users repeatedly circumvent official workflows, they are effectively redesigning the product through behavior. At some point, every software team faces the same decision urban planners eventually encounter when a dirt trail appears across the lawn:
Pave the path people actually want, or continue pretending the sidewalk was correct all along.
Leave a Reply