AI strategist Nate B Jones argues that generative UI is making software interfaces disposable, and that the real value in software is shifting to the underlying data substrate
Solo presentation by Nate B Jones of AI News & Strategy Daily.
Summary
Nate B Jones argues that the release of Google's image generation model (which he refers to as "Nano Banana Pro") marks a tipping point in how software interfaces are built and valued. He contends that for 40 years, coherent user interfaces were an economic necessity — expensive to build and therefore designed to be shared by millions — but that generative AI is making pixels cheap and contextual, fundamentally decoupling the interface from the product. His central argument is that software is splitting into two layers: a durable substrate (data models, domain logic, compliance, workflows) that retains deep value, and a disposable pixel layer that will increasingly be generated on demand by AI agents for individual users in specific moments. He draws out the implications for B2B SaaS vendors, designers, product managers, and engineers, arguing that the products and people who win will be those who treat UI as a runtime output rather than a frozen artifact — and that vendors who insist users live inside their monolithic interfaces will be routed around by agentic tools.
Key Takeaways
FULL TRANSCRIPT
The tipping point: why this moment changes everything
Nate B Jones: 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. I want to dig into what that means.
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 good or bad. 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?
I want to break this into a few moves and we're going to go through them one by one. 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. Let's jump into it.
Move one: coherent interfaces were an economic hack, not a law of nature
Nate B Jones: For 40 years, we treated user interfaces as scarce because they were expensive to design, expensive to build, expensive to QA, to localize, to document, to train on. I still remember the days of on-prem, in-the-basement Oracle servers. That's the world we lived in, where software and hardware were both very expensive. 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 iStore. Oracle iStore — 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 iStore'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 iStore stayed the same for a long, long time because no one wanted to change it and Larry could keep making money.
That meant we optimized our organizational structures around coherent and long-lived interfaces. We would have opinionated interaction design. We would have navigation. We would have page layouts with 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 hand-tooled.
That is no longer true. And we need to recognize that this moment — this two- or three-week period — is the tipping point. We've seen signs of it before, but this is the moment it all changed.
Three overlapping shifts driving the tip
Nate B Jones: Generative and agentic waves are making pixels cheap and contextual, and we just hit that tipping point in the last couple of weeks. You have three overlapping shifts happening at once and reinforcing each other to drive this tip.
First, generative user interfaces — models that can spit out full screens from text or context. You have UISard, Vzero, Galileo. They already generate multi-screen mock-ups from prompts. Nielsen has talked about this as the dawn of cheap, disposable UI. I don't care how far down the hype train you go. The key is to recognize that ephemeral user interfaces are popping up everywhere. There's an entire startup called Wabby that just allows you to make generative interfaces and software for yourself as a personal consumer. You can have generative interfaces in Comet, generative interfaces in other smart browsers. So generative UI is becoming a thing.
Number two, ephemeral and generative UI concepts are exploding. There's a growing conversation around what hyper-contextual applications or panels might look like — how we might create and destroy them while keeping the application state the same. That is different from the technology itself. Generative UI is about the technology and the user interface. The idea of UI concepts — really the design language — is growing, and we need a new design language for this change we're all going through.
The third trend is agentic software that drives other software. This is actually where Nano Banana Pro 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, and other places — with screenshots, with videos. People are using the API call to pass a string of data in a structured prompt query to Nano Banana Pro and retrieve a chart or a graph that they can then display as the past week's sales, the past day's customers, whatever internal metrics they need. They can just automatically query and get a nice chart back from Nano Banana Pro. That is generative interface driven by agentic software.
Fundamentally, the interface is something that is starting to morph based on user context, and it isn't staying fixed anymore.
What disposable pixels actually mean for software
Nate B Jones: 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 vibe-coded apps has been a recognition from folks who've done this over 20 or 30 projects — they find 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.
Nano Banana Pro is basically a future-leaning version of this. A model that understands UI structures, sketches, and diagrams, and 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 thinking Nate thinks software is dead, or that software won't exist anymore. That's not true. I think the opposite. But I do want to talk through what this means, because I think software is going to profoundly change.
The three-layer model: substrate, agent, and pixel
Nate B Jones: 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. The things that B2B SaaS was good at — they don't die. They just move downward in the stack. 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. That's the hard stuff. Domain logic, forecasting, pricing engines, how you handle interconnects, APIs, and webhooks. This layer 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 value-dense. It's where moats 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. This is the layer that interprets. If you say, "Show me which enterprise customers in EMEA have renewal risk this quarter, 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 SaaS company that isn't working on some version of layer two. In fact, most businesses are working on some version of layer two for their back-office operations, because this kind of experience is what we have all wanted software to be and we never got the 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. With an agentic layer over the top of a solid data foundation, we finally have that chance. 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 auto-executed.
Layer three is pixels — but not pixels as the hand-tooled, crafted objects that we had to live with back in the Oracle iStore days. I mean pixels as a compiled artifact of intent. Only when it needs your judgment does the system compile pixels in this model. It might be a one-off panel — a ranked table of at-risk customers, an inline suggested outreach, a toggle for "send now" or "schedule." It's a transient visualization — a specific 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.
The durable core versus the disposable layer
Nate B Jones: I am not trying to suggest that all of the UI is going to be composable. 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.
There are going to be common cores in our software stacks that remain durable even in their UI. Think of it as the homepage for a B2B SaaS that shows you customer conversations — you want that homepage to be easily navigable, and you don't want it to be new and different every time. That kind of UI is here to stay. It's not going to be AI-driven.
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 ChatGPT when we have shared conversations and ChatGPT creates an artifact that we both view together.
So interfaces are becoming a two-class object. You have durable, permanent interfaces — a common core with high habit, the front door of the application — and this disposable layer that makes up for a lot of the pages that were hand-tooled before and never got a lot of traffic.
Anyone who has managed a SaaS application will tell you that traffic decays stochastically — it decays 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 are largely at risk during this transition. We are going to see SaaS applications that only have two or three main pages, and everything else may be generated for the user on the fly. The user may be able to save a particular view if they like it, but fundamentally those pages are going to be much more composable.
Comparing traditional interfaces to disposable pixels
Nate B Jones: I want to be really clear about how different a coherent, consistent, hand-tooled interface is versus a disposable pixel interface. If you lay that out across 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. For disposable pixels, it can be done in seconds. The design target for a traditional interface involves a lot of people focused on personas, roles, and generalized workflows. 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.
The mental model for a coherent interface app is "learn this app." I want to really emphasize this 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 ChatGPT 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. That could not be more different than assuming the app is static and you can learn it.
The cost structure is also completely different. Instead of a heavy upfront cost for traditional software, disposable pixels have heavy model training costs — 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, is still dirt cheap relatively speaking.
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. In the disposable pixel world, it lives mostly inside the agent planning and the durable state and record layer. It is not in the pixels. A lot of 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 is also different in itself. In the traditional software days, if you were pitching your software in the VC era, you would call out look and feel, interaction design, UX patterns, the smarts of the machine learning inside, the cleanness and efficiency of your workflow, how well you understood the problem. With disposable pixels, you call out the outcomes — because the AI agents are doing more and more of the work. You call out the speed from intent to action.
As an example of that 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. Ten 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. We are fooling ourselves if we think anything else.
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.
What this means specifically for B2B SaaS
Nate B Jones: I want to go a bit deeper on the B2B SaaS side, partly because I am very deep in B2B SaaS myself, and I think this hits B2B SaaS profoundly. Whether you're buying B2B SaaS, leading a B2B SaaS company, or building in B2B SaaS — this is a big deal.
The disposable pixel story is extra complicated here, and it justifies a sidebar. Right now, today, a ton of the enterprise value in B2B SaaS is framed around this idea that we own the primary surface where the job happens. CRMs 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 touchpoint anymore. Your API behavior and 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 SaaS 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.
It 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. Your canonical UI is just one of many frontends. You're competing with internal task panels, with co-pilot-generated micro-apps, with perhaps a third-party universal workspace tool that comes along. You are at risk of having the relationship disintermediated because you get aggregated with many other SaaS products behind one agentic interface.
Where SaaS 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. That means you are embedded in domain flows that track real value. SLAs, compliance, reference data — being safe and predictable for agents to call is a way to win. If you have strong schemas, good safeguards, and idempotency — say that three times fast — in a disposable pixel world, you become less of a thing with screens and more of a high-integrity service that agents and generators can rely on.
What this means for designers, PMs, and engineers
Nate B Jones: 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 are moving from owning specific flows and screens pretty rapidly into defining interface grammars, defining constraints, 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 the questions are: what intents do we support? What state changes must be safe? What decisions need human judgment versus being fully automated? Instead of creating a static wireframe, you're moving to a world where you're speccing out intent, state, and outcome loops. That's really different.
Engineers — especially front-end engineers — are used to front-end pixel pushing. 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.
Your interface backlog for designers, PMs, and engineers begins to change here. Instead of traditional tickets that come in in Jira, you have new intents 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."
Where coherent traditional software still wins
Nate B Jones: There are places where coherent traditional software still wins. Cognitive mapping is a big one. Humans do like stable landmarks. If you are doing complex work — trading, 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. The 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.
Audit, training, and compliance is another big area. 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. 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. 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. Shared work needs shared views. "Look at this dashboard. Check this queue." If everyone has a different ephemeral panel, you need explicit mechanisms for pinning, sharing, and standardizing those panels.
I'm going to go out on a limb and 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. 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.
The mature pattern: a spectrum, not a binary
Nate B Jones: 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.
It is okay that we have both. We do not have to insist on a binary fight, as I see so many times — where people will say "B2B SaaS 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 SaaS applications." That is just not true. Anyone who has managed a serious SaaS 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.
What this means for builders, leaders, and talent
Nate B Jones: When I step back and look at the implication of this Nano Banana moment for builders, for leaders, for talent, the thing 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 moat on the substrate? If you're in talent — in design, in PM, in engineering — where are you 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 SaaS survives as the substrate, and there will be coherent cores that survive up to the UI layer, with data-providing agentic intelligence layers over the top. But fundamentally, pixels themselves as 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. 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.
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 moat is that their interface is beautiful. Vendors who resist being called by higher-level agents and insist that users live inside their monolith. You can only do that for so long — people will find a way around it.
One of the implications of Nano Banana Pro is that a computer-use agent that is very good is not far behind. 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 monolithic 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.