Intelligent Pixels: From Durable UI to Disposable Interfaces
Key Points
- The industry is moving from “product as an interface bundle” to treating the product as a durable substrate where individual pixels become cheap, disposable elements.
- Nano Banana Pro is cited as the tipping‑point catalyst that demonstrates how generative and agentic technologies can make pixels inexpensive and context‑aware, heralding a new wave of intelligent displays.
- For the past four decades, coherent interfaces were an economic hack—expensive design, QA, localization, and training forced organizations to build long‑lived, shared UIs (e.g., the infamous Oracle Eye Store) and invest heavily in certifications and change‑management.
- Recent advances in generative AI have shattered that cost barrier, allowing pixels to be generated on‑the‑fly, which makes static, one‑size‑fits‑all interfaces obsolete.
- This paradigm shift will reshape software strategies, influencing decisions about building vs. buying tools and how talent is allocated across design, development, and AI‑driven personalization.
Sections
- Rethinking Interfaces with Intelligent Pixels - The briefing explains how the emergence of technologies like Nano Banana Pro is driving a shift from treating user interfaces as scarce, shared bundles to viewing products as durable substrates with disposable pixels, and outlines the resulting software‑build, buy, and talent‑allocation strategies while debunking the myth that coherent interfaces are a natural law.
- Rise of Ephemeral Generative UI - The speaker outlines how cheap, disposable interfaces and AI‑driven, context‑aware UI panels are proliferating, prompting a new design language and agents that autonomously generate and manipulate software components.
- Agentic Layer & Intent Pixels - The speaker describes how AI agents (layer 2) automate tasks across CRM, data warehouses, and other back‑office systems, while UI elements (layer 3 “pixels”) are generated only as compiled intent when human judgment is needed.
- Composable Interfaces vs Disposable Pixels - The speaker contrasts traditional, high‑traffic web pages with emerging on‑the‑fly, agent‑driven UI components, emphasizing traffic decay, risk to low‑traffic pages, and the shift to highly composable “disposable pixel” interfaces that can be created in seconds rather than months.
- Redefining Roles in Generative UI - The passage outlines how designers, product managers, and front‑end engineers must shift from crafting static screens to defining interface grammars, intent specifications, and safe, composable shells that support generative UI systems.
- Slack's Evolving Role in Generative UI - The speaker argues that Slack’s stable collaboration platform is becoming a hub for generative‑UI agents and plug‑ins—allowing standardized workflow shells alongside flexible, disposable UI elements—demonstrating that traditional B2B SaaS can coexist with emerging generative interfaces.
- Rise of Agent-Addressable Interfaces - As data needs expand beyond analysts, products that are agent‑addressable, schema‑clean, and composable will dominate, while monolithic UI‑centric solutions lose relevance to agents that let users pick their own interfaces, reshaping both consumer and business experiences.
Full Transcript
# Intelligent Pixels: From Durable UI to Disposable Interfaces **Source:** [https://www.youtube.com/watch?v=x-01UrScIrA](https://www.youtube.com/watch?v=x-01UrScIrA) **Duration:** 00:26:14 ## Summary - The industry is moving from “product as an interface bundle” to treating the product as a durable substrate where individual pixels become cheap, disposable elements. - Nano Banana Pro is cited as the tipping‑point catalyst that demonstrates how generative and agentic technologies can make pixels inexpensive and context‑aware, heralding a new wave of intelligent displays. - For the past four decades, coherent interfaces were an economic hack—expensive design, QA, localization, and training forced organizations to build long‑lived, shared UIs (e.g., the infamous Oracle Eye Store) and invest heavily in certifications and change‑management. - Recent advances in generative AI have shattered that cost barrier, allowing pixels to be generated on‑the‑fly, which makes static, one‑size‑fits‑all interfaces obsolete. - This paradigm shift will reshape software strategies, influencing decisions about building vs. buying tools and how talent is allocated across design, development, and AI‑driven personalization. ## Sections - [00:00:00](https://www.youtube.com/watch?v=x-01UrScIrA&t=0s) **Rethinking Interfaces with Intelligent Pixels** - The briefing explains how the emergence of technologies like Nano Banana Pro is driving a shift from treating user interfaces as scarce, shared bundles to viewing products as durable substrates with disposable pixels, and outlines the resulting software‑build, buy, and talent‑allocation strategies while debunking the myth that coherent interfaces are a natural law. - [00:03:13](https://www.youtube.com/watch?v=x-01UrScIrA&t=193s) **Rise of Ephemeral Generative UI** - The speaker outlines how cheap, disposable interfaces and AI‑driven, context‑aware UI panels are proliferating, prompting a new design language and agents that autonomously generate and manipulate software components. - [00:07:52](https://www.youtube.com/watch?v=x-01UrScIrA&t=472s) **Agentic Layer & Intent Pixels** - The speaker describes how AI agents (layer 2) automate tasks across CRM, data warehouses, and other back‑office systems, while UI elements (layer 3 “pixels”) are generated only as compiled intent when human judgment is needed. - [00:11:28](https://www.youtube.com/watch?v=x-01UrScIrA&t=688s) **Composable Interfaces vs Disposable Pixels** - The speaker contrasts traditional, high‑traffic web pages with emerging on‑the‑fly, agent‑driven UI components, emphasizing traffic decay, risk to low‑traffic pages, and the shift to highly composable “disposable pixel” interfaces that can be created in seconds rather than months. - [00:18:23](https://www.youtube.com/watch?v=x-01UrScIrA&t=1103s) **Redefining Roles in Generative UI** - The passage outlines how designers, product managers, and front‑end engineers must shift from crafting static screens to defining interface grammars, intent specifications, and safe, composable shells that support generative UI systems. - [00:21:38](https://www.youtube.com/watch?v=x-01UrScIrA&t=1298s) **Slack's Evolving Role in Generative UI** - The speaker argues that Slack’s stable collaboration platform is becoming a hub for generative‑UI agents and plug‑ins—allowing standardized workflow shells alongside flexible, disposable UI elements—demonstrating that traditional B2B SaaS can coexist with emerging generative interfaces. - [00:25:01](https://www.youtube.com/watch?v=x-01UrScIrA&t=1501s) **Rise of Agent-Addressable Interfaces** - As data needs expand beyond analysts, products that are agent‑addressable, schema‑clean, and composable will dominate, while monolithic UI‑centric solutions lose relevance to agents that let users pick their own interfaces, reshaping both consumer and business experiences. ## Full Transcript
This week's executive briefing is all
about the future of intelligent pixels.
We're moving from product as an
interface bundle to product as a durable
substrate with pixels as throwaway. And
I want to dig into what that means. And
yes, the catalyst for this is Nano
Banana Pro and the transformation it has
brought to the way we think about
images. But I look at Nano Banana Pro as
really the tip of the spear. I'm not
interested in whether you think this
particular model is I'm interested in
this as a tipping point and we'll see
more models that are even better than
this in the future. So what does that
mean for our software strategies? So I
want to break this into a few moves and
we're going to go through them one by
one and by the end I think you're going
to see where we're ending up from a
software build perspective, from a
software buy perspective, even from a
talent allocation perspective. So let's
jump into it. Number one, coherent
interfaces were an economic hack, not
necessarily a law of nature. For 40
years, we treated user interfaces as
scarce because they were expensive to
design, they were expensive to build,
they were expensive to QA, to localize,
to document, to train on. I still
remember the days of onprem in the
basement Oracle servers, right? Like
that's the world we live in where
software and hardware were both very
expensive and that meant when you got an
interface it had to be shared and serve
thousands and millions of users and use
cases. I used Oracle eyes store. Oracle
eyes store sorry to anyone out there
who's from Oracle is a terrible terrible
terrible interface. It is absolutely
awful. I have deleted half a store
because of Oracle is store's terrible
interface, but it had to be shared by
thousands and millions of users and my
preferences didn't matter. Interfaces
had to be durable. You had to amortize
the design and development cost for
years. So, Oracle Eyes Store stayed the
same for a long long time because no one
wanted to change it and Larry could keep
making money. So, that meant we
optimized our organizational structures
around coherent and longlived
interfaces. So we would have opinionated
interaction design. We would have
navigation. We would have page layouts
that had very clear mental models
embedded. We had training. We had
certifications. Has anyone ever been
Salesforce certified? Has anyone been
Workday certified? Anyone certified in
how to use Jira? This is what I mean.
This also meant there was huge change
management overhead for any major UI
shift. that made sense when every pixel
essentially had to be handtoled. That is
no longer true. And we need to recognize
that this moment, this 2, 3 week period,
this is the tipping point. We've seen
signs of it before, but this is the
moment it all changed. Generative and
agentic waves are making pixels cheap
and contextual, and we just hit that
tipping point in the last couple weeks.
You have three overlapping shifts
happening at once and reinforcing each
other to drive this tip. First,
generative user interfaces are models
that can spit out full screens from text
or context. You have UISard, Vzero,
Galileo. They already generate
multis-creen mock-ups from prompts.
Neielson has talked about this as the
dawn of cheap disposable UI. I don't
care how far down the hype train you go.
I think the key is to recognize that
ephemeral user interfaces are popping up
everywhere because they kind of in fact
there's this entire startup called Wabby
that just allows you to make generative
interfaces and software for yourself now
as a personal consumer. You can have
generative interfaces and comet
generative interfaces in other smart
browsers. So you have generative UI
becoming a thing. Number two, ephemeral
and generative UI concepts are
exploding. And so there's a growing
conversation around what hyper
contextual applications or panels might
look like and how we might create and
destroy them and keep the application
state the same. That is different from
the technology itself. So generative UI
is about the technology and user
interface. The idea of UI concepts
really the design language is growing
and we need a new design language for
this this change we're all going
through. The third trend is agentic
software that drives other software.
This is actually funny enough where Nano
Banana Pro I think rightly comes in.
Google smartly placed their image
generator right out of the gate on an
API so that agents can call it and come
back with images. People who are
enterprising are already using this for
interface design from Nano Banana Pro. I
am not talking about theory. I'm talking
about what I actually see on X on Reddit
other places with screenshots with
videos. People are using the API call to
pass a string of data in a structured
prompt query to NanoBanana Pro and
retrieve a chart or a graph that they
can then display as the past week's
sales, the past days customers, whatever
it is that they need for internal
metrics, they can just automatically
query and get a nice chart back from
Nano Banana Pro. That is generative
interface driven by Aentic software.
Fundamentally, the interface is
something that is starting to morph
based on user context and it isn't
staying fixed anymore. So, if you put
that together with the idea of throwaway
pixels, fundamentally, you have software
that's changing in value. Software is
becoming generated on demand from intent
and context. It's becoming private to
the user in the moment for that
particular ask. It's becoming discarded
when that moment passes. One of the most
instructive descriptions of vibecoded
apps has been a recognition from folks
who've done this over 20 30 projects
that they are finding that these apps
are valuable in the moment and some of
them they may use again but some of them
they created just for a single use and
that was worth it to them. So Nano
Banana Pro is basically a futureleaning
version of this. A model that
understands UI structures, sketches,
diagrams, and it flows well enough that
UI just becomes one more output modality
like text or code. That's your
disposable pixels. Before I get too far
down the road, I don't want you to walk
away at this point and think Nate thinks
software is dead or Nate thinks that
software won't exist anymore. That's not
true. I think the opposite. But I do
want to actually talk through what this
means because I think software is going
to profoundly change. So let's look at
what disposable pixels actually look
like in practice. I want to call out
three layers. Layer number one is the
system of record or the system of
decisioning. So in this sense the things
that B2B SAS was good at, they don't
die. They just move downward in the
stack. So data models, workflows,
permissions, audits, compliance, things
that we paid for when we purchased the
software, things that we pitched when we
wanted to be entrepreneurs and make
money off of building stuff. It was this
hard stuff, right? That's moving down
the stack. Domain logic, forecasting,
pricing engines, how you handle uh
interconnects, APIs, and web hooks. This
layer, frankly, is durable. It isn't
going anywhere. Nano Banana Pro is not
taking that away and neither is any
other image generator. It is very valued
dense. It's where Moes live. It's why
I'm not super worried about Salesforce
for the medium to long term. Layer
number two above that system of record
is intent planning and operation. And
this is the layer that interprets it
says show me if you say show me which
enterprise customers in AMIA have
renewal risk this quarter and give me a
CSM touch gap no longer than 45 days and
then please draft an outreach email.
That's a series of tasks that an AI
agent can pick up pass off to other AI
agents and start to execute against the
system of record. Layer two is becoming
an agentic layer. It's not all the way
there yet, but I don't know anyone who
operates a B2B SAS company that isn't
working on some version of layer 2. And
in fact, most businesses are working on
some version of layer 2 for their back
office operation because this kind of
experience is what we have all wanted
software to be and we never got a
chance. If you remember back when I said
software was something we had to conform
to, we never really wanted that. We
wanted software to be more personal and
with an agentic layer over the top of a
solid data foundation, we finally have
that chance. So that means the agent can
hit your CRM, it can hit your customer
data warehouse, it can run the queries,
it can call the email system, the
ticketing system, it can decide what
needs a UI and what ought to be
autoexecuted. All of that can happen and
then you can finally get to the UX.
Layer three is pixels, but not pixels as
the handtoled crafted objects that we
had to live with back in the Oracle eyes
store days. I mean pixels as a compiled
artifact of intent. So only only when it
needs your judgment does the system
compile pixels in this model. It might
be a one-off panel, right? It may have a
rank table of atrisisk customers. It
might have an inline suggested outreach.
It might have a toggle for send now
schedule and design. And it's a
transient visualization. It's a specific
cohort ch cohort chart or funnel for
this question only and a narrow editor
UI for exactly one structured decision.
In other words, we are moving to a world
where at least some of the UI does not
generalize. I am not trying to suggest
that all of the UI is going to be
composable. And part of why I'm not is
that we are creatures of habit. We have
a lot of assumptions around how UI ought
to look and we do get used to our
software products pretty quickly and we
don't like it when they change. I think
there are going to be common cores in
our software stacks that remain durable
even if they're UI. Think of it as the
homepage for a B2B SAS that shows you
customer conversations and you want that
homepage to be easily navigable and you
don't want it to be new and different. I
think that kind of UI is here to stay.
It's not going to be AIdriven. I think
the key is that there are going to be a
whole new class of user interfaces that
nest under that that are going to be
heavily used that are generative that
are throwaway that are rendered at
runtime for that particular person. We
are arguably already doing this when we
create an interface on the fly through
perplexity and then share that throwaway
interface with one or two other people
as a way of talking about a topic. We're
starting to do it in chat GPT when we
have shared conversations and chat GPT
creates an artifact that we both view
together. So interfaces are becoming
this sort of twoclass object where you
have durable permanent interfaces that
may be a common core that has high habit
that is the front door of the
application and this disposable layer
that sort of makes up for a lot of the
pages that were handtoled before that
never got a lot of traffic. Anyone who
has managed a SAS application will tell
you that traffic decays stochastically.
Traffic decays like this on an
exponential curve and your top two or
three pages account for most of your
traffic. But you have to put just as
much work into all these other pages
that only a couple of people want. Those
are the pages that I think are largely
at risk during this transition. We are
going to see SAS applications that only
have two or three main pages and
everything else may be generated for the
user on the fly. Sure, the user may be
able to save it in some place so they
can come back to it if they like that
particular view, but fundamentally
they're going to be much more composable
than and that brings me, I think, to a
chance to talk about the differences
here because I want to be really clear
about how different a coherent
consistent handtoled interface is versus
a disposable pixel pixel interface. If
you want to lay that out and talk about
different horizons and axes of value,
they could not be more different. The
time horizon for a traditional interface
is measured in months at best. And for
disposable pixels, it can be done in
seconds. The design target like you
often have a lot of people focused on
personas, roles, generalized workflows
for your fancy interface. And for
disposable pixels, the agent is going to
decide. It's not going to be a human.
the agent is going to put a user, a
moment, and a goal together and go
somewhere. Your mental model for a
coherent interface app is learn this
app. And I think that is actually one I
would really like to emphasize from a
talent perspective. Most of the talent
at tech companies and at non- tech
companies still has the mental model of
learn this app and they've brought that
with them to chat GPT in the AI era.
that does not serve you because the
world we're moving to with disposable
pixels is more like what AI actually is.
State your intent, do the prompt, and UI
appears when needed. And that could not
be more different than assuming that the
app is static and you can learn it. And
I think so much of the time we assume
that the cost structure, I've called
this out, it's so different. Instead of
a heavy upfront cost for traditional
software, disposable pixels, they have
heavy model training, but the pixels are
functionally free. The models have been
paid for and you can get cheap, cheap,
cheap iteration. Even Nano Banana Pro,
which is relatively expensive now and
will get cheaper, it's still dirt cheap,
relatively speaking. The consistency is
something I want to call out. This gets
viewed as a concern for a lot of
generative interfaces. Consistency value
is obviously very high for traditional
software. It is mostly inside the agent
planning and the durable state and
record layer. It is not in the pixels.
And I think that a lot of times
proponents of generative UI fail to make
this connection. They tend to say that
generative UI is whatever you want it to
be without recognizing that it has to
rest on a durable software substrate
that does not change that is not
ephemeral. Differentiation or how
software differentiates from others is
also in and of itself different. So let
me explain what I mean. In the
traditional software days, if you were
pitching your software as VC era, we
were software is better. You would call
out look and feel. You would call out
interaction design. You call out UX
patterns. You'd call out the the smarts
of the machine learning inside. You
would call out the cleanness and
efficiency of your workflow. The way
you'd understood the problem. With
disposable pixels, you call out the
outcomes because the AI agents are doing
more and more of the work. You would
call out the speed from intent to
action. And as an example of speed, it
took me 10 seconds to craft a perfect
chart of GDP annually in the US and
Germany compared on the same chart in
Nano Banana Pro from 1960 to 2025. 10
seconds. You're not going to beat that
with a traditional BI tool. The speed
from intent to action is addictive and
it is driving consumer and business
behavior. And I think that we are
fooling ourselves if we think anything
else. Look, coherent interfaces are not
going to disappear. They're just going
to stop being the default shape of
software. They're going to become
perhaps a fallback when tasks are
ambiguous. They're going to become a
shared frame for multi-user
collaboration. They're going to become a
meta surface where you orchestrate
agents. It's just going to look
different. I want to go a bit deeper
here on the B2B SAS side partly because
I am very deep in B2B SAS myself and I
think this also hits B2B SAS profoundly
and I want to call that out for if
you're like buying B2B SAS or if you're
a leader in B2B SAS if you're a builder
in B2B SAS that should cover a lot of
folks. This is a big deal. So the
disposable pixel story is extra
complicated and I think it justifies a
little sidebar here. First I want to
call out that right now today a ton of
the enterprise value is framed around
this idea that we own the primary
surface where the job happens right so
CRM think that way ERPs think that way
HR information systems think that way
PLG analytics systems think that way if
the primary interaction moves to an
agent or co-pilot surface then your own
UI is just a reference implementation
it's not the default touch point anymore
and so your API behavior behavior, your
data semantics matter more than your
navigation bar. So the bundling power
shifts from is this the system with the
best dashboard, which is what sales has
sold on in B2B SAS for a really long
time, to is this the system that is
easiest for agents to choreograph. And I
think a lot of companies don't have a
good answer to this. Also means that UI
is becoming a product surface that you
do not fully control. If customers are
using generative UI tools on top of your
APIs, they are letting their own
internal design systems and their own
models render their own views of your
data. And then your Canon UI is just one
of many frontends. And so you're
competing with internal task panels,
with co-pilot generated micro apps, with
perhaps a third party universal
workspace tool that comes along. In
other words, you are at risk of
disintermediating the relationship
because you get aggregated with many
other SAS products behind one agentic
interface. And so where SAS still wins
is where it's able to be a substrate as
a service where you own the canonical
state for something, the contracts, the
ledgers, the records, the risk models,
whatever it is. And that means that you
are embedded in domain flows that track
real value. So SLAs's compliance
reference data being safe and
predictable for agents to call is a way
to win. So if you have strong schemas,
if you have good safeguards, if you have
item potent item potency, say that three
times fast, in a disposable pixel world,
you become less of a thing with screens,
which is what most software has been,
and more of a high integrity service
that agents and generators can rely on.
Let's transition to the talent side.
What happens to designers, PMs, and
engineers in a world where we start to
have generative UI? For designers, you
have to shift the way you think, right?
You're the designers on your team, the
designers you hire. If you're a designer
listening to this, you are moving from
owning specific flows and screens pretty
rapidly into defining interface
grammarss, into defining constraints,
into like figuring out safe snap points
for generative UI. You are becoming
language designers and safety engineers
for human attention. If you're a PM,
you're used to a world where what
feature or page do we build next is the
core question. You're moving to a world
where what intents do we support? What
state changes must be safe? What
decisions need human judgment versus
being fully automated? So instead of
just creating a static wireframe, you're
moving to a world where you're trying to
spec out intent, state, and outcome
loops. And that's really different.
Engineers, especially front-end
engineers, are used to front-end pixel
pushing. And now you need to start
thinking about building stable
interfaces for agents and generators and
a thin canonical shell. You may want to
build something that enables those snap
points. You may want to build something
that enables validation logic. You may
want to build something that enables a
degree of composability within safe
constraints. And so your interface
backlog for for designers, PMs, and
engineers begins to change here because
instead of traditional tickets that come
in in Jera, you have new intents that
you want to support, new system
behaviors, new constraints or
invariants, new components or layouts
the generator might use. It's not just
add another settings page. Now I do want
to call out there are places where
coherent traditional software still
wins. Cognitive mapping is a big one. So
humans do like stable landmarks. I
mentioned this earlier. If you are doing
complex work like trading, like
medicine, incident response, people rely
on deep spatial memory of their tools.
Completely shifting pixels every time
adds cognitive load and risk. This is
one of the places where I think
perplexity is making an incorrect choice
in the finance space. Bloomberg terminal
may look like a maze to most people, but
it is software that people with a deep
spatial memory of the tools rely on for
complex work. It is not getting
disintermediated by perplexity finance.
Whatever perplexity says there's a floor
of coherence that you cannot cross
without hurting performance. I would
also like to call out audit, training,
and compliance is a big flow here.
Regulated environments need very
reproducible flows. Show me exactly what
the user saw when they approved the loan
is not something where you can say it
was a generative interface. So IDK like
that's not going to work with an
auditor. Ephemeral UIs make this very
hard unless you can capture and version
the UI spec itself as a first class
artifact and that gets very very
complicated very very fast. I think that
the the incentives are strongly in favor
of coherent software there. Team
collaboration is probably also a space
where you're going to see coherent
software. So shared work needs shared
views. Look at this dashboard. Check
this queue. And if everyone has a
different ephemeral panel, you need
explicit mechanisms for pinning, for
sharing, for standardizing those panels.
I am going to go out on a limb and I'm
going to suggest I don't know this is
true, but I'm going to suggest that
Slack has basically this vision for
their product roadmap. Slack is becoming
a place that is benefiting from the move
to generative UI. Not because Slack is
itself a generative UI. It's very
stable, but because it is stable and it
is a place where teams collaborate and
know the interface well. It is a place
where all those hooks that Slack has
built into other tools can become
passively agentified. The agentified
benefits can just flow into Slack as a
value proposition. And so when people
build charts in Nano Banana Pro, the
demo videos they do always show them
popping the chart back into Slack where
the team can see it. That is not an
isolated incident. That is where Slack's
value proposition is starting to shift
as a stable team collaboration substrate
in a generative UI world. So the mature
pattern is probably a spectrum. You're
going to have highly standardized and
coherent shells for regulated flows, for
shared operational views, for team
training and onboarding, for team
collaboration, and you're going to have
disposable pixels that operate inside
that shell for exploratory analysis, for
micro decisions, for personalized
shortcuts, for just for me flows. I want
to suggest to you that it is okay that
we have both and that we do not have to
insist on a binary fight like I see so
many times where people will say B2B SAS
is dead and only generative UI is the
future. We will never have stable
interfaces. That's a terrible take. But
an equally terrible take is we will
never see generative UI interfaces in
serious SAS applications. That is just
not true. And anyone who has managed a
serious SAS application as I have will
tell you that we have hundreds or
thousands of pages that we're managing,
many of which we would dearly love to
make generative because they're so
expensive to maintain through the
traditional rubric. And so when I step
back and look at the implication of this
nano banana moment for builders, for
leaders, for talent, I think the thing
that I want to leave you with is this.
Software really is decoupling. It's
decoupling into a substrate that needs
to be stable and a pixel that matters a
whole lot less. If you are in the
business of either pixels or substrates,
this is going to affect you. You should
pay attention. You should think about
your moat. Is your mode on the
substrate? You should think if you're in
talent, if you're in design, if you're
in PM, if you're in engineering, where
are you at in relation to the substrate
and the pixels? Are you stuck in a world
where you're pushing coherent software
and you don't see a way forward or are
you moving to that world where you have
the substrate, the agentic intelligent
layer and the disposable pixel? I do
believe B2B SAS survives as the
substrate and there will be coherent
cores that survive up to the UI layer,
data providing agentic intelligence
layers over the top etc. But
fundamentally pixels themselves as the
the single coherent interface for a
product are going to go away. We have
seen that going away for a while as BI
teams have leaned more and more into
just give me the data for data platforms
and data vendors. They don't want the
fancy dashboard the sales guys sell.
They just want the data. Well, now we're
moving to a world where it's not just
the data science team saying that. It's
the marketers. It's everybody is saying
that. So who wins? Products that are
agent addressable. Products that are
schema clean. Products that can be
composed. Teams that treat UI as a
language and a runtime, not as a set of
frozen screens. And that goes for you as
an individual. It goes for the people
you hire. Who loses? Products whose only
mode is that your interface is
beautiful? Vendors who resist being
called by higher level agents and insist
that users live inside their monolith.
Like you can only do that for so long.
people will find a way around it. One of
the implications of nano banana is that
a computer use agent that is very good
is not far behind. And even if you
insist on living in the monolith, you
could see a world in 2026 where the user
can just get up in the morning, have a
voice conversation with an agent, and
the agent can use a tool to go and
browse the monolith software that you
insist only a human can use, extract the
data, and bring it back to the user. The
user is going to be able to make their
choices. The user is going to be able to
choose their interface. This is going to
be true for consumer. It's going to be
true for business. And it's going to
change everything.