There’s a strange feeling settling over the digital world. On one hand, the applications and websites we use every day are starting to feel… similar. The same clean lines, the same friendly sans-serif fonts, the same few-column layouts. A sea of polished, functional, and ultimately predictable interfaces. This is the age of digital convergence, a landscape smoothed over by efficiency and best practices.
Yet, at the very same time, from the weird, bubbling fringes of the internet, things are getting stranger than ever. We’re seeing an explosion of hyper-niche, single-purpose tools, bizarre digital art projects that defy categorization, and personalized software so finely tuned to one person’s brain that it’s practically unusable for anyone else.
We are witnessing the great split in software development, a paradox driven by the exact same force: the rise of Large Language Models (LLMs) and AI coding agents. These powerful tools are pushing software in two opposite directions at once. They are making it more homogenous and templated (“boring”) by optimizing for the average, while also making it more fragmented and experimental (“weird”) by drastically lowering the cost of creation.
Let me explain …
Why Software is Getting More Boring
The “boring” side of the paradox isn’t about a lack of functionality. In fact, software is more powerful than ever. Instead, it’s about a loss of soul, a creeping uniformity that stems directly from how AI models learn and create. They are engines of statistical probability, and their output inevitably trends toward the mean.
Uniform UI/UX Patterns
AI code tools tend to default to popular frameworks (e.g. Bootstrap, TailwindCSS, Shopify themes, etc.) and well-known design styles. This is because these tools are trained on vast amounts of publicly available code, which overwhelmingly follows these conventions.
In practice this means landing pages and dashboards often “blur into one another,” with little visual distinction. It’s fast and “safe” to reuse these templates (and easy for an LLM to regurgitate them), but it makes everything look the same. Over time the net effect is a flattening of creative UI diversity: sites feel generic or “out of the box” because the AI uses the same color tokens and components everyone else uses
At this point I have to say: I sometimes like it this way. I think most people are like me; They don’t have the skills to produce inspired design themselves, but still expect software to not look ugly, and know what clean design is, based on their experience of using other software. When they make software for themselves, they just want something to be “decent enough” and then move on to the functionality part.
This does come at the cost of inspired design, but it’s not a big deal. The average user doesn’t care about the design, they care about the functionality. And if they do care, they can always customize the design to their liking.
Boilerplate Code Reuse
Large language models are trained on huge repositories of existing code. When a developer asks for a feature (login system, CRUD API, etc.), the LLM will often spit out standard boilerplate solutions drawn from those sources. While this is efficient, it also means many projects end up with nearly identical underlying code. In effect, the AI is assembling snippets lifted from thousands of GitHub repos or StackOverflow answers.
Developers rarely rewrite these from scratch, so the end results are very similar patterns (same file structures, naming conventions, library calls). The AI isn’t inventing new algorithms; it’s remixing proven, workaday code. This convergence leads to “samey” codebases – boring but functional.
Over-Reliance on Popular Libraries
Relatedly, LLMs (and the developers who use them) gravitate toward the most popular languages and frameworks. If you prompt ChatGPT to make a web app, chances are it will pick React/Express or Django/Laravel, because that’s what its training data shows most often. These mainstream stacks dominate many answers, so relatively little code is generated in niche or exotic languages.
The result is that most new apps look and behave like the countless others built on those same technologies. Innovation in choice of tools is rarely the focus; instead, everyone uses the “boring” tried-and-true options that the LLM recognizes and the team understands.
It will be very interesting to see what the next major library/framework in web development might be for example. I remember when React came out, it wasn’t the first library to use the component-based architecture. But it was the first library to use the virtual DOM, and it changed the way we think about web development. Will there be another framework which challenges the way we think about web development and introduce new patterns to the mainstream the same way React did?
React is just an example, but I’m sure you can find similar examples in your corner of software development which are similar. What would it take for the next great library/framework to challenge the way we think about software development?
Safe, Conservative Solutions
AI-assisted coding encourages safe defaults. An LLM’s suggestions are typically the minimal solution that works, not an offbeat or experimental one. Developers tend to prompt for what they know or have seen – for example, “make a simple signup page with these fields” – and the model produces a straightforward implementation. It’s rare that someone asks the AI to try a wildly different UX just for novelty (and even if they did, the model still pulls from existing examples).
In short, productivity incentives push people toward the simplest solution. The outcome is practical but not surprising: if everyone is balancing tokens/time vs. novelty, the default is to keep UIs and features quite standard and utilitarian.
Homogenization of Ideas
LLMs can actually homogenize creative output. For instance, I recent read a paper found that different users producing ideas with ChatGPT ended up with “less semantically distinct ideas” than those using other tools. By analogy, when developers use AI helpers, they often converge on the same patterns and designs.
Instead of spark new ideas from scratch, teams copy what the AI suggests, and the AI itself tends to suggest the most common approaches it has seen. Over time this creates a self-reinforcing loop: everyone ends up with similar designs or code see patterns repeated across projects. The novelty fades because the AI – trained on conventional solutions – doesn’t introduce truly unique inventions in code.
Why Software is Getting Wierder
Now (almost) everybody can “vibe-code”. This has unlocked people’s access to not just using software, but creating software too.
Previously non-technical people had to rely on technical people to make software, but they feel they don’t need them to such an extent. We can talk later about how this introducing more disruptions, complications and potential bugs and vulnerabilities, but that’s for another day.
Regardless, even technical people are using LLMs to create software (I would wager that they are actually using more in terms of quantity and intelligently than non-technical people to make software).
Hyper-Personalized Micro-Apps
LLM-powered coding lets individuals quickly whip up extremely niche applications for very personal use cases. In other words, people are now building tiny one-off utilities on demand. Some are making story-book apps for their children using specific details they know about their kids. Some are building niche workout tracking apps, language coaching software, and I recently just made a small fun quiz app to help my kids with prep for an exam.
Most of these kind of software will never get funded, not even get bootstrapped. Yet, they provide value to a specific set of people and solve a specific problem.
Unusual Feature Combinations
With AI assistance, developers can easily mash up unrelated ideas into a single product. For instance, someone might prompt: “Make an RPG-style fitness tracker that dialogues with me in medieval language,” or “Build a cooking app that also gives poetry feedback.”
The AI will happily incorporate elements from any references it has – so you get a wild hybrid. In the past, creating such crossover features might have been too complicated. You might even feel wierd or embarrassed to suggest some of these combinations, but with AI, you can just ask and get a working prototype.
Now LLMs democratize experimentation: it’s trivial to ask for a chatbot with a grumpy pirate persona as your scheduler, or a forum that grades posts with random memes. These novel combinations make software feel unexpected or “weird,” because they break from the usual genre conventions. AI lowers the bar for creativity, so more applications have playful or eccentric twists in functionality that a strict development budget might have precluded.
Fast-fashion of Software
While much of the software might last quite a while, a lot of these apps are built to be thrown away. They are built to solve a specific problem for a specific set of people. They are not meant to last. They are meant to be thrown away.
Because generation is instant, software can exist for only a moment. You might spin up a custom app to help you and your friends decide on a restaurant for dinner, complete with a voting system and map integration. Once the decision is made, the app is discarded, having served its single purpose. This represents a radical cultural shift, viewing software not as a monumental product to be maintained for years, but as a disposable tool created for a fleeting task.
This is also where we see the “acceleration of bad ideas.” When it costs nothing to try, every shower thought gets realized. Anti-social media platforms, pet-ranking apps, recursive to-do lists that add more tasks as you complete them—most of these ideas will fail, but the sheer volume of experimentation guarantees that truly novel and bizarre concepts will emerge from the chaos.
Conclusion: A Flatter Mainstream and Stranger Fringes
So, is software becoming more boring or more weird? The answer is a resounding “yes.” The paradox resolves itself when we realize these are not contradictory trends but two sides of the same coin of rapid, AI-driven synthesis.
The boringness comes from statistical averaging. By drawing from the vast repository of what has worked before, LLMs excel at producing the median, the common, the “good enough.” This force smooths out the mainstream, making our primary digital experiences more uniform, predictable, and reliable, but also less inspired.
The weirdness comes from low friction. By dropping the cost, time, and skill required to create something new to virtually zero, LLMs empower individuals to explore the strange, niche, and hyper-personal ideas that would have previously been unthinkable. This force creates an explosion of diversity at the fringes, populating the digital world with a beautiful and chaotic ecosystem of bizarre and wonderful creations.
The fundamental nature of software is changing. It is becoming less of a monolithic, handcrafted artifact and more of a fluid, malleable, and disposable medium. For everyone who interacts with technology, from the casual user to the veteran developer, the essential question remains: In this new world, what kind of software will you choose to build or use? Will you contribute to the polished, predictable center, or will you venture out into the wild, weird, and unknown frontiers? The most exciting future may belong to those who find a way to bridge the two.