AI’s UI Problem Is Actually A New Era of Software

AI looks the same today: a prompt box, a blinking cursor, a call to “ask anything.” 

This visual sameness invites accusations of commoditization, but critics are looking in the wrong place. While traditional software broadcasts differentiation through interfaces (Salesforce’s fields, Slack’s channels), AI’s value lies elsewhere: not in what you see, but what you don’t.

The critical layer is invisible: logical scaffolding around the foundation model that determines what context to pull, which tools to invoke, and how to sequence operations. This middle layer—once dismissed as “middleware” binding interfaces to data—is now the product itself. It’s what separates Cursor from Lovable from Claude Code, and demo toys from production tools.

As AI shifts value from interfaces to logic, we’re witnessing the next era of enterprise software: systems of work. These programs don’t capture value through proprietary data or intuitive UX, but through the hidden architecture that transforms raw AI capability into real business automation.

The Three Eras of Enterprise Software

To understand the rise of systems of work, it’s helpful to start with where enterprise software has traditionally created value.

Simply stated, modern software apps consist of three layers: the database and data model (record layer), the user interface and UX (engagement layer), and the business logic that connects them (work layer). The history of software innovation follows the shifts in value creation between these three layers.

Software 1.0: Systems of Record

The first great enterprise platforms—Oracle (financials), Salesforce (customers), Workday (employees), and ServiceNow (technology)—captured value by controlling vital business data. On top of this core asset, these systems imposed rigid schemas and workflows via clunky interfaces, and if anything did not fit, it was discarded. Yet companies remained locked in anyway; the data gravity was inescapable. As the saying went, “If it’s not in Salesforce, it didn’t happen.”

Software 2.0: Systems of Engagement

Eventually, frustration boiled over. Clunky workflows weren’t just annoyances; they were actively slowing businesses down. As users demanded consumer-grade app experiences, systems of engagement decoupled from systems of record. Slack, Zoom, and Notion transformed how businesses collaborated. These systems didn’t own the underlying records but made them usable, layering on intuitive UIs and workflows that accelerated velocity. Value shifted decisively to the engagement layer.

Software 3.0: Systems of Work

Software 3.0, unlocked by AI, shifts the value yet again: this time, to the invisible work layer that contains an application’s business logic. In deterministic software, this middleware was just plumbing, and its components—API integrations, event buses, ETL pipelines—were lost on all but architects and engineers tasked with ensuring Input A reliably produced Output B.

But AI systems aren’t deterministic. The work layer no longer just shuttles data; it must dynamically decide what context to supply, what tools to call, and when to act versus observe. These architectural decisions, once dismissed as implementation details, now define the entire product experience. 

This represents a dramatic shift in value creation. The work layer now subordinates the ones around it—reducing systems of record to commodity context stores and interfaces to occasional checkpoints that become increasingly infrequent as copilots evolve into autonomous agents. Systems of work don’t just connect UI to data anymore; they encode the logic that determines what users experience and what outcomes they achieve.

The Hidden Value of Systems of Work

Systems of work are a recent phenomenon, even by AI standards.

In fact, the first few years of the AI platform shift were driven almost entirely by models rather than their scaffolding. As foundation models crossed new capability thresholds—in text generation, summarization, transcription—killer apps emerged in lockstep.

GPT-3.5 enabled ChatGPT and Harvey. Voice and transcription advances made ElevenLabs and Abridge possible. These pioneering applications wrapped powerful models with domain-specific adaptations, but their success hinged primarily on the models’ impressive zero-shot performance rather than the data harness around them. (Tellingly, many first-wave winners were vertically integrated model providers, rather than pure-play app companies.)

But as AI takes on more complex workflows that increasingly interact with other enterprise systems, the logic layer is now becoming paramount. Within the way context is constructed, tools and memory are exposed, and model behavior is orchestrated, the scaffolding plays a crucial role in delivering starkly different results.

Just consider how three coding assistants—Cursor, Lovable, and Claude Code—transform similar user inputs, interfaces, and data into radically different end products through their different architectural choices.

• Cursor optimizes for developer flow state. Every architectural decision targets sub-second latency: pre-indexed codebases with Merkle tree synchronization for instant updates, hot-path caching for near-zero file access time, sub-20ms vector queries for context retrieval, and speculative decoding that validates token predictions in parallel.

• Lovable inverts every one of Cursor’s assumptions. Built for non-technical users creating web apps from scratch, it deliberately constrains choice to guarantee success: pre-defined templates, opinionated tech stack (React + Vite + Tailwind), bounded codebases that fit within context windows. The business logic limits technical choices to better guarantee reliable full-stack generation that consumers can iterate on without encountering any underlying infrastructure complexity.

• Claude Code takes yet another path, built for engineers navigating massive, legacy codebases where understanding beats speed. Instead of pre-indexing everything, it explores context in real time—reasoning through file systems like a human developer would. Its async generator approach lets it iteratively compact context and adapt plans mid-task as new information surfaces, making it ideal for multi-file refactoring or debugging problems that require true codebase comprehension.

Same models. Same interfaces. Completely different products, use cases, and even end users.

Looking Ahead

In the era of systems of work, interfaces no longer carry the burden of differentiation. The prompt box so ubiquitous among today’s AI apps isn’t a sign of commoditization, but rather a recognition that value has shifted elsewhere—from visible UI states to hidden orchestration logic.

Over the next decade, this shift will redefine how applications are built, how businesses choose them, and how value accrues in software. The winners of this new era will not be defined by their UIs, but by the intelligence and effectiveness of their systems of work.