← blog

The End of UIs

2026-02-23 · apis, economics, building

The UI layer used to be owned by the company that built the service. Now it can be owned by the person using it.

That's not a prediction — it's already happening. "APIs beat UIs" is a decade-old take, and APIs have always existed. What's new is that the cost of building on top of them just collapsed. One person can rebuild GitHub's entire frontend. An AI agent can build a Telegram client inside VS Code. When cost trends to zero, any non-zero amount of demand is enough to make something happen.

The Evidence

FasterGH

Rhys Sullivan rebuilt GitHub's entire frontend. One person. GitHub's API stays the write model; Convex acts as a real-time read cache via webhooks. The result loads PRs faster than GitHub does — because it doesn't serve 100 million developers' edge cases. It serves his.

Our Local Build

We have an AI agent building a Telegram client as a VS Code extension. Not a human dev — an agent. It talks to Telegram's API, renders messages in the editor sidebar, with hardcoded UI for agent interactions and inline GitHub PR rendering. Still rough, but it works. Build time: one session per feature.

Capabilities, Not Apps

Here's the deeper shift: apps will no longer be the basic unit of software. Capabilities will.

When a custom UI costs six months and a team of five, you tolerate the app you're given. When it costs one person one weekend, you stop thinking in terms of apps and start thinking in terms of what each service can do. GitHub isn't an app — it's a capability: code hosting, PRs, CI. Telegram isn't an app — it's a capability: real-time messaging. Stripe isn't an app — it's a capability: payments.

Every user becomes their own product manager. You assemble your command center from capabilities — the specific bits and pieces of various APIs, arranged for maximum effectiveness of your workflow. Think traders building their own Bloomberg from APIs. Developers embedding chat, git, and AI into one surface. Personal productivity setups that look nothing like anyone else's.

Composition: The Actually New Thing

This is the first-order effect: hyper-customization of single services. The second-order effect is more interesting — you compose capabilities from multiple services into interfaces that no single company would ever build.

Here's a concrete example from our local build. We have a Telegram client in VS Code with hardcoded special UI for talking to AI agents — custom rendering for structured responses, inline action buttons, context from your codebase. When someone pastes a GitHub link, it renders the PR status, diff stats, and a merge button inline. Chat + merge PRs + query your AI agent — one surface, zero tab-switching.

That's Telegram API + GitHub API + OpenClaw API = one bespoke interface. No single company would build this. But when cost is near-zero, "too niche" isn't a valid objection anymore.

The Stack That Wins: Composition APIS Telegram messages, media GitHub PRs, issues, CI OpenClaw agent sessions Calendar events, reminders Your API anything else COMPOSE Your Bespoke Interface APIs composed, not consumed SHORTCUTS Merge PR from a chat message without opening GitHub Agent UI custom rendering for AI agent responses Context Inject drag a file into chat agent sees the code One surface. Zero tab-switching. Every shortcut a generic UI can't justify. Interfaces no single company would build. Because no single company has the incentive.

What Breaks

If this plays out — if users start owning their UI layer and assembling capabilities instead of buying apps — the knock-on effects are significant.

Upselling from the UI dies

If the user controls the interface, you can't put upgrade prompts in their face. The entire "free tier with annoying limitations" playbook assumes you own the screen. You don't anymore.

Per-seat pricing gets weird

When one person's bespoke interface hits five APIs, who gets the "seat"? Pricing per-capability or per-call makes more sense than pricing per-human-looking-at-your-UI.

Feature tiers blur

Tiered pricing assumes users want your features. But if they're composing their own experience, they might only want your data layer. The feature you're gating might be one they've already built.

SaaS brand power fades

When your product is consumed through someone else's interface, your brand becomes invisible. You're a capability, not a destination. The moat is the API, not the logo.

Apps that don't play nice — that lock down their APIs or force you through their UI — will get replaced by local or open alternatives. Unless they have irreplaceable network effects, a closed API becomes an invitation for someone to rebuild you from scratch.

The Takeaway

The default UI becomes the demo. The real product is the API. And the real interface is the one you — or your agent — built last weekend.

We're building tools that assume this future. Follow our work on the blog or subscribe to RSS.