One Company, One UX: Great Teams Ship Opinionated Custom Enterprise Software
Why Enterprise Solutions Stop Working When They Work for Everyone
One of the big fallacies of the 21st century is that we’re somehow seeing faster technological progress than the previous century.
I just finished reading Boom: Bubbles and the End of Stagnation. It’s a great book that makes a case against this myth. While it might seem like we’re advancing, the yearly delta in technological progress is much smaller today than in the 1940s.
As Tyler Cowen mentioned, we’re in the great stagnation. But, why?
The Illusion of Progress
The big issue with the current technology companies is that they’re littered with low-conviction management teams that encourage “cargo cult programming.” The need for high-margin software revenue led to modular software that tries to do everything for everything.
Take Salesforce’s recent announcement of Agentforce as an example. While it offers flexibility, it’s a classic example of how unopinionated management teams build: a horizontal no/low-code platform that does everything for everyone. Ask yourself this: is the future of AI really yet another no/low-code AI Agent platform?
This kind of "innovation" doesn’t solve fundamental problems; it merely creates the illusion of progress while shifting inefficiencies elsewhere.
Modularity and Its Discontents
One of the most telling examples of this stagnation is the rise of modular software systems. Companies like Salesforce, Oracle, and Microsoft have built vast ecosystems of tools designed to address a broad array of business needs. While modularity has its benefits, it also stifles innovation. These systems are deliberately generic, requiring extensive customization to meet specific requirements. This approach creates a dependency on consultants and integrators, locking businesses into ecosystems that prioritize vendor profitability over user empowerment.
Moreover, modular systems encourage a one-size-fits-all mentality. Instead of fostering creativity or enabling businesses to develop custom solutions, they enforce conformity. Businesses end up adapting to the software rather than the software adapting to their needs. This homogeneity not only limits the scope of innovation but also entrenches inefficiencies.
Cargo Cult Programming
The modularity problem feeds into a broader issue in the tech industry: “cargo cult programming.” This term describes a development culture where superficial adherence to best practices takes precedence over deep problem-solving. Developers are incentivized to rely on pre-built frameworks, APIs, and libraries to deliver features quickly, even if these tools aren’t the best fit for the problem at hand. This leads to bloated, inefficient systems that prioritize speed and scalability over craftsmanship and robustness.
Rather than building systems from first principles, many companies focus on delivering functionality as quickly as possible, regardless of quality. This mindset prioritizes checking boxes over genuine innovation, reinforcing the cycle of stagnation.
The Cultural Shift in Technology
Beyond incentives and programming practices, there has been a profound cultural shift in tech. The mid-20th century was marked by a spirit of exploration and a willingness to tackle grand challenges. Today, tech culture is increasingly risk-averse. Social media apps, delivery platforms, and subscription-based software dominate because they offer low-risk, high-reward business models.
This focus on safe bets stands in stark contrast to the era of the moon landing or the invention of the microchip. Back then, failure was an accepted and even expected part of the process. Today, the fear of failure discourages the kind of bold experimentation that leads to transformative breakthroughs.
In the mid-20th century, technological progress was driven by a combination of existential necessity and bold investment in long-term, high-risk research. Governments and private institutions poured resources into projects like the space race, the Manhattan Project, and the development of early computing. These efforts were focused on solving grand challenges, and the benefits—though often unpredictable—were transformative.
Breaking Free from Stagnation
If we want to escape the great stagnation, we need to rethink how we build software:
Build opinionated industry-specific software: LLMs will enable the rapid development of tailored solutions for specific industries, moving away from the "jack-of-all-trades" approach of modular platforms. For example, instead of forcing a healthcare provider to adapt to a generic AI tool, LLMs will make it cheaper for teams to deliver a bespoke solution that understands medical workflows, compliance regulations, and patient needs.
Custom UX: Future companies will combine modular components with tailored UX, delivering personalized solutions to enterprises. LLMs will lower development costs, enabling high-quality, customized workflows without compromising scalability or profitability. I’m not discouraging modularity, but modularity at the cost of UX is bad.
Encouraging Craftsmanship: The tech industry must shift away from the "cargo cult" mentality and embrace a culture of craftsmanship. Developers should be encouraged to build systems from first principles, prioritizing solving real user problems over speed and scalability.
If you want to build opinionated software for hard-to-disrupt laggard industries, consider joining us at Layerup.