Creating software in 2028 is so amazing now that we build with reusable UI components!

We’re getting much closer to a world where we can create sophisticated applications from widely reusable, general-purpose user interface components. We’re still not there — it might be another 5–10 years before that world comes to pass. But we can imagine what software development will be like once that’s happened.

Here in the year 2028, we’re lucky to share enormous public collections of reusable components implementing every user interface pattern under the sun. Every old-school UI technique you can think of — menus, carousels, shopping carts, Pull to Refresh, plus all the cool stuff that was invented in the 2020s — everything you need is already coded for you!

Just think of how good we have it now:

• Designers and devs readily adopt common UI patterns without hesitation. They never wonder how hard it will be for the team to implement a pre-existing UI, because they can always find a rock-solid implementation of it in the comprehensive component libraries.

• We see constant experimentation. Because switching to a different pattern is trivial, designers play with and test multiple ideas before settling on a solution.

• Visual design tools let us work with palettes of UI patterns. These days, it goes without saying that designers and developers collaborate directly on the same artifacts that define an app. But it wasn’t that long ago that designers would create static design images or limited prototypes, and developers would laboriously translate those to running code. (Honest, they really had to do that!) These days, our design tools can edit the front end definition directly. Not only that, they provide integrated access to catalogs of UI patterns as components. Adding or modifying complex interactions can now be accomplished through drag-and-drop. That shift dramatically accelerated development, further encouraged experimentation, and generally made designing a blast.

• You see a lot more variation in common patterns than one saw in the 2010s. It used to that variation came about almost accidentally because people had to implement patterns from scratch. Now designers and devs create variations when they want to. They can extensively customize generic components or build new variations that reuse substantial behavior from existing generic components. Even complex patterns can be adapted to new contexts and still retain much of their reusable value.

• We’ve seen a burst of domain-specific innovation. Because teams no longer waste time reinventing wheels, they now focus primarily on their business domain’s specific challenges and their app’s unique value. We’ve also seen the introduction of large domain-specific pattern libraries for specific industries. The apps we use now are far, far better as a result.

• Fewer people are required to design and implement basic UI.

• You probably create UIs alongside many people with deep expertise in fields other than UI design. Once working with UI building blocks became easy enough, more people could do it, which opened up the field to a huge number of new participants.

• If you’re young, you may not even remember a time when companies had to build their product UI multiple times for different OS platforms. What a colossal waste of time and money that was!

• Good ideas now spread faster. When the Thought Crystals user interface pattern first appeared in beta in April 2025, the creator contributed a solid reusable implementation, and it spread like wildfire. By May, the new pattern had completed displaced VR hamburger menus.

• Common patterns have been extensively studied and documented. For any given pattern, you can access a wealth of academic and industrial research about it: the precise circumstances where it is most useful, metrics showing where how and why it goes wrong, comprehensive galleries showing the pattern in actual use, and suggestions for best practices in specific contexts.

• Coded patterns gave us all a consistent vocabulary that reflected both user experience and developer implementation. Once we had real implementations of all the common patterns, everyone building apps could talk about UI the same way.

• We rarely come across apps with terrible UI fundamentals. Back in the day, one could hardly shop online without constantly tripping over aggravating menus, intrusive dialogs, and flaky carousels. Ignorant companies today still produce bad apps with bad designs, of course, but at least the fundamental interactions in those apps still meet a decent quality bar.

• People with permanent or temporary disabilities have better experiences across the board. At minimum, an app’s fundamental UI provides a higher baseline of reasonable interaction than one typically found in 2018.

• Branded user experiences have become far more immersive. Corporations customize UI in a deep way, far beyond theming fonts or colors. They adapt all aspects of interaction: the types and speeds of animated effects and sounds, the quality of voice dialogs, the tightly-focused microbrands for specific markets, and the general personality of a UI’s construction. Even boring apps today in 2028 exhibit the same degree of pizzazz as games did back in 2018.

• You now design some aspects of your apps at a meta-level. For certain UI problem domains, you can just specify the general parameters of the problem, and let the system make limited decisions about the best UI pattern for the situation. Sophisticated apps now use AI to track user behavior and adapt which patterns are used in real time.

• While the component implementations in our universal pattern library have been rewritten several times over, the patterns themselves have proved quite durable. While we now use much better frameworks that were available in 2018, the patterns themselves are timeless. When we saw major shifts in programming languages and techniques in the early 2020s and again in 2025, it was relatively easy to upgrade the patterns and the apps which depended on them.

Isn’t user experience design in 2028 great? It’s interesting to realize that all the benefits above were already possible 10 years ago — we just didn’t realize it. All it took was for us to recognize the value of implementing common UI patterns as reusable components and start really sharing them.