#1 Manage Complexity
The Hardest Part of Design is Invisible
Facing those bloated, labyrinthine product structures, I often come to a realization: as products scale, complexity is almost unavoidable. But the problem is, human brains don’t evolve at the same speed as the system itself.
Many people think design is about making things simple, or stripping features away. But after wrestling with complex systems year after year, I’ve realized good design rarely removes complexity completely.
Most of the time, design is about managing it.
Think about how we understand anything at all. Language starts with sounds, which become letters, then words, and finally sentences. We build understanding piece by piece. Cognitive psychologist George A. Miller once noted that our working memory can only handle a limited amount of information at the same time.
Interfaces work the exact same way. Nobody logs in and instantly digests an entire ecosystem. They grasp one small corner, then another, slowly building a mental map of the whole thing.
It’s like turning on your navigation app in a completely unfamiliar city.
Before you hit "Start," the full map is overwhelming. You’re staring at a dense web of highways, exits, directions, and distances all at once. But the moment navigation begins, the system stops asking you to comprehend the entire city.
- Turn left in 200 meters
- Go straight
- Keep right
The Complexity Didn’t Vanish, It Was Just Reorganized
Did the city’s complexity disappear? No, it was just reorganized. The system broke one massive, terrifying problem into a series of local, manageable tasks.
When you add a new feature, it’s never just a local change. It creates new dependencies, ripples through the existing structure, and adds immediate cognitive weight. It’s like pulling a single loose thread and watching the whole sleeve bunch up. When a tiny change in one corner forces users to relearn the entire product, it’s a clear signal: your system structure is under immense pressure.
When this one part changes, do people need to rebuild their entire understanding of the system?
If the answer is yes, it's too tightly coupled. You're making them carry too much weight.
If the answer is no, you’ve done your job. You've allowed their understanding to grow progressively.
This isn’t some rigid rule from a textbook. It’s just a painful pattern I’ve observed repeatedly while working on complex products that want to do everything at once.
#2 Human Interface
Systems Can Be Complex, But Interfaces Must Be Simple
Systems can be complex, but interfaces must be simple. It sounds like a cliché, but in so many industries, complexity is the norm—often taken completely for granted. The underlying layers of these products are packed with endless states, rules, and technical constraints. They make perfect sense to engineers, but to the vast majority of users, they are pure alien language.
Look at current AI products. We are living through a phase of powerful yet chaotic infancy. The underlying capabilities are astonishing, but the learning curve required for deep usage is incredibly steep.
From a human perspective, this can mistakeably be called a true user experience.
Users just want to get a simple task done, yet the product forces them to understand how the entire engine works first. This isn’t unprecedented; so many complex products suffer from the exact same disease. Over time, people just silently accept it—as if the system is naturally meant to be this frustrating, and the user is supposed to bear the burden.
But the reality is: an overly complex system is usually just because our ability to translate this new technology hasn’t kept up, and we haven’t yet learned to fully master it.
According to Tesler’s Law, every system has an inherent amount of complexity that cannot be stripped away. The common belief is that design makes things simpler. But in reality, design rarely reduces complexity—the system itself remains complex. What actually changes is where that complexity is redistributed. Good design is about finding that exact sweet spot between technical backends and human cognitive load, ensuring that complexity resides where it is best handled.
Hide unnecessary processes.
Under the premise of balancing design and technical details, do not force users to deal with cognitive costs completely irrelevant to their intent the moment they enter.
Retain critical decision points.
Intent-driven design is by no means a black box. Designers must precisely distinguish between superfluous complexity and essential complexity.
Take DeFi (Decentralized Finance), for example. The word "Approve" is pure system language, but it represents a critical risk boundary. Good design simplifies the operation while ensuring users retain final control over risks like slippage, security, and asset authorization. The task of design is to provide progressive disclosure. There is a delicate balance when pursuing intent-driven design: we must not strip away the user’s right to know for the sake of extreme simplicity. Those seemingly complex pieces of information are the vital foundation for a user’s decision-making.
The Moment Design Drives Mass Adoption
More than ever, humans need to occupy the decision-making layer, while the system acts as the supporting layer. This makes the defining moments of design more critical than ever before. Through an elegant abstraction layer, complex parameters are transformed into intuitive interactions. If a user encounters a failure, the interface must offer transparency and explainability, helping them understand the reason behind the error instead of trapping them in the distrust of a technical black box.
A designer’s job is not just drawing UIs. Only when designers build better abstraction layers to turn powerful features into intuitive actions can the adoption of AI truly scale.
Products should stop exposing their complexity. Instead, they must establish an interaction model that aligns more closely with human thought.
Enable people to take action based purely on their intent, without requiring them to become engineers first.
#3 Moving Complexity
Good Design Never Makes Complexity Vanish
The truth is, in high-complexity systems, it is fundamentally impossible to truly eliminate complexity. It doesn’t matter if it’s AI systems, developer tools, finance, or blockchain—they are all built this way.
The real question is: who has to bear it?
The real question has never been about complexity itself, but rather: who has to bear it?
Some products choose to bury complexity deep within the system; others choose to expose it raw, directly to the user. The choice between the two is the thin line between life and death for a product experience. There are so many products out there with explosive features, incredible capabilities, and hyper-advanced backends, yet using them just feels exhausting. The reason usually isn’t that there are too many features—it’s that the product got lazy and passed the system’s burden straight down to the user.
- Comprehend tedious processes
- Manually manage various states
- Keep track of complex dependencies in their heads
- Blindly guess the system’s next move
- Handle the system’s edge cases and exceptions yourself
This complexity—which should have been quietly swallowed by the system underneath—is dumped onto human cognitive load instead. But the human brain was never wired to sustain that kind of high-intensity, overloaded state for long.
This has become painfully ironic in the world of AI Agents right now. You think a multi-agent system represents a more advanced, highly efficient future? Most of the time, it just takes problems that should have been solved in the core architecture—or problems that shouldn’t even exist in the first place—and shifts them into heavier Token consumption.
The system looks like it got smarter, but the user’s life becomes absurd.
- Debug the agents
- Exhaustingly manage the context windows
- Constantly correct system hallucinations
- Fragilely maintain complex workflows
- Untangle the headache-inducing dependencies between different agents
Rebuilding Human Comprehension and Agency in High-Complexity Systems
A good solution is never about letting the tool demand that humans adapt to it. Otherwise, what we ultimately learn isn’t how to solve problems; we merely learn how to become maintenance workers for the system. When a tool begins demanding human adaptation, and when the transfer of complexity fails, the system’s capabilities begin to outpace the limits of human understanding.
Re-anchoring human comprehension and agency within high-complexity systems—that is where the true value of design lies.
Design never makes a system genuinely simple. The key is knowing how to arrange where the complexity lives. Good design builds a structure. It allows the system to be massive, and it allows localized parts to be hyper-complex, while keeping the whole thing intuitively understandable, ensuring humans don’t have to bear the entire weight of the information load all at once.
The most fascinating part of design is building an interface that actually works right at the intersection of human cognitive limits and crazy system complexity. As the world becomes increasingly virtual and chaotic, the designs that still allow people to understand, act, and feel a true sense of control are the ones that become truly priceless.