For most of my career, the interface felt like the thing you were building.
You designed the dashboard. You mapped the workflow. You refined the states, tuned the hierarchy, polished the visual system, and tried to make something durable enough that a team could rely on it for years. The interface was the product. It was the thing people returned to, learned, trusted, and built habits around.
Lately, I have been thinking about what happens when that stops being true.
We are moving into a world where teams can generate dashboards, summaries, decks, PDFs, charts, and reports on demand. A leader can ask for a portfolio snapshot before a meeting. An operator can spin up a filtered view for a weekly review. A team can create a narrative brief instead of manually assembling slides. The interface is no longer something that always has to be carefully authored once and maintained forever. Increasingly, it can be created in the moment.
That shift is exciting, but it also changes the nature of the design problem.
Because once interfaces become easy to generate, the interface itself stops being the scarce asset. What becomes scarce is the structure underneath it. The data model. The shared definitions. The contextual notes. The permissions. The publishing rules. All the invisible things that determine whether a generated artifact is actually trustworthy or just convincing-looking.
That is the part I keep coming back to.
The real risk is not that teams will generate ugly outputs. The real risk is that they will generate polished ones that quietly disagree with each other. One summary uses a different definition of progress. Another pulls in draft data. A third strips away the caveats that made the original metric meaningful. Everything looks finished, but the organization slowly loses its grip on what is actually true.
So I do not think the future of organizational software is no interface.
I think it is many interfaces, created as needed.
But if that is where things are going, then the design challenge moves down a layer. The work becomes less about producing one perfect surface and more about designing the system that makes many surfaces coherent. In that world, the most important product may not be the dashboard at all. It may be the governed core that sits beneath it.
I tend to think of that core as four connected layers: canonical data, semantic logic, contextual framing, and publishing rules. The data tells you what exists. The semantic layer tells you what it means. The context layer explains why it matters. The publishing layer determines how it can be shaped, shared, and trusted across different audiences.
That leads to a principle I find increasingly useful: one core, many views.
Not everyone needs the same interface. In fact, forcing everyone into the same view is often the wrong goal. Leaders need concise synthesis. Operators need detail and drill-down. Technical stewards need lineage and validation. Different audiences need different artifacts, different levels of abstraction, and different forms of explanation. The goal is not one universal dashboard. The goal is one trusted core that can generate many views without losing consistency.
This is also why I do not think AI inside organizations should behave like a free-form generator with unrestricted access. It needs to act more like a governed publishing engine. It should inherit permissions, respect audience boundaries, and understand which outputs are exploratory versus official. Otherwise the system starts collapsing distinctions that matter, between raw and approved, between internal and external, between useful flexibility and organizational chaos.
The more I think about it, the more I feel this is where design is heading. We will still design interfaces, of course. But we will also increasingly design the conditions that make generated interfaces usable and trustworthy in the first place. Semantic models. Context structures. Publishing workflows. Traceability. Permission-aware generation rules. Systems that preserve meaning even as the surface keeps changing.
That is the part that interests me most.
Because if interfaces are becoming disposable, then coherence is becoming the real product.
And the organizations that do this well will not just be the ones that can generate more artifacts, faster. They will be the ones that can generate them from a shared core of trusted data, structured context, and visible rules for how information becomes something people can act on.
