Primitives over pixels
When anyone can build an interface in an afternoon, what is a software vendor actually selling?
For most of the history of enterprise software, buying meant buying a roadmap. The vendor owned the interface, the data model and the feature queue. Customers filed requests and waited, and their leverage arrived once a year at renewal. The arrangement made sense because interfaces were expensive to build, so whoever built them held the power.
That cost has collapsed. With an AI assistant, a small team can produce a working dashboard, a bot or a bespoke workflow in an afternoon. The interface is turning from the product into a disposable surface, and the relationship between buyer and vendor is starting to reorganise around what remains scarce.
An example: a governance portal
Take an onchain governance portal, the official site where a token community proposes, votes and delegates. Its renewal used to be a list of screens: a new filter, a better timeline, notification settings. Now suppose the operators have already built their own alert bots and review tools on the portal's API, each in a few days. Their renewal list reads differently.
| Layer | What it holds |
|---|---|
| Buyer builds | Edge interfaces: trackers of who hasn't voted, alerts, agents, analysis. |
| Vendor serves | Primitives: complete history, events pushed as webhooks, Markdown documents, keys the buyer controls. |
| Vendor runs | The canonical interface: one official, legitimate place where votes happen. |
The asks move down the stack. If the portal shows a number, the API must serve it. Every button needs a name an agent can find. Payment follows acceptance tests. The contract includes data export, readable code and the right to host a read-only mirror if the official site fails.
What vendors sell instead
The vendor still matters, but its value shifts from building screens to guaranteeing things. Is the data complete and correct? Does it arrive on time? Will the schema hold still long enough to build on? Is there one interface everyone trusts as official? Those are harder problems than drawing pages, and they are easier to price, because reliability can be measured.
Where this is going
- Headless by default. Software ships its API and event stream first, and its own interface as a reference implementation that customers are free to replace.
- Agents become a primary user. Accessibility trees, named controls and machine-readable docs stop being compliance chores and become the main way software gets operated.
- Contracts become executable. Scopes are written as test suites that agents run on every release, and acceptance happens automatically.
- Exit rights become standard. Data portability, mirror rights and source access move from special concessions to table stakes, the way uptime commitments did.
- The canonical layer gains value. When every user can have a personal interface, the one official interface carries the legitimacy, and that becomes the vendor's moat.
The open problems
A thousand personal interfaces can show a thousand slightly different numbers. Someone has to own correctness when a vibe-coded tracker misreads a vote. Copies of official sites make convenient phishing templates. The answer is probably a small trusted core with strong guarantees and a large, cheap edge around it.
The old relationship ran on dependency. The new one runs on clean contracts between layers: the vendor keeps the core solid, and buyers build at the edges.