The view is dead. Long live the view
Published 2026-11-03, About 17 minute read.
In a year, I will be shocked if humans are generating views. And yet they are the most important part of what we deliver as software engineers. As every youtuber and instagrammer says after a shocking cold open like that: let me explain.
I've been quite impressed with the one-pager HTML pages that Claude can assemble. I can ask it to take markdown notes and dress it up as a fully styled one-file HTML page, or it can be transformed into a neatly styled HTML slide deck. I've used this to get personalized guides on classic novels, distance running training, and complex abstract math topics.
To demo how effective these views are, I asked Claude Code to do the following from my blog:
I want you to make a one-pager summary of my analysis of frameworks along the three axes in my most recent blog series on this blog. Make the file an html file for my most recent post- I want to be able to embed it in an iframe. It should be professionally styled and include source links so people could navigate to specific parts of what your summary mentions.
And here's the result with no iterations or tweaking, all in a single HTML file:
Notice it matched my website styles and design pretty faithfully. It summarized in a parsable way, and included a few ways to sort and drill down. Sure, there are some annoying Claude-isms, but consider that we have Star Trek level AI capabilities here.
This is probably not news to you. I see people in my organization increasingly relying on this type of view to learn complex parts of the code base and draft and communicate RFCs and other technical documents.
But it was generated in about 30 seconds, and it's iterable.
Do you need this document to be less wordy?
Do you want this to be dark mode or actually just a sparse outline?
Do you need this doc as a slide deck instead?
Do you need this doc to pop and have a few carousels in carousels? (Don't skip checking this one out, the visualization is pretty neat, even though the page I'm sure is an accessibility monstrosity!)
Iterating is easy- Claude has the primitives, the information, and the target goals to build views for specific purposes. The important bit is this: the view is assembled almost immediately, can be adjusted, and is ultimately throwaway. What would have taken a human maybe a day or two to assemble parts, style, and create, Claude is able to assemble in a minute.
The view as we used to know it is dead. The user views will be almost solely generated by AI, iterated and incremented on with the help of AI, and for the most part views will not be the durable product for people using our platforms. We've been spending 95% of our efforts in the front end on this view, and this has been hiding the true source of value we provide in our feature development and work.
The view was always the most expensive, laborious, and slowest part of feature building π
And it isn't even the source of value.
Consider this: when you build a platform you have a "lasagna" of layers. This is the pace layering for component libraries that Brad Frost and many others have championed, and I think it's a great model for component architecture. Here is what pace layers might look like for your regular org.
The idea is that the component library is the slowest and most difficult to change, because it is the foundation stone that all else is built on. This makes sense- if you're going to have a strong building, you need a strong foundation. Then, as we gradually build up larger abstractions, we combine components to make molecules, and these molecules are assembled into views. Then, collections of views are the "feature."
In reality, the view is the resource-suck. In theory, since all the APIs and design decisions have been "decided already" through APIs for all the layers below it, the view is supposed to be supa fast. In reality, making views takes 95% of your resources. Often, you have the data, the components, and the way you want to organize it. You spend time having designers assemble these pieces together. You spend time wiring it up by hand. You spend time getting QA feedback and iterating. You spend more time when the client wants to be able to do X, and that requires going back to design, going back to the developer, having long conversations about how X will fit into your platform and stay consistent. Time is spent figuring out if you should duplicate the view and make a different one that has X, or if you should extend the view to include an option for X. You spend time with accessibility people to re-assess the view changes and whether the new combination of X and Y cause issues with focus or announcements.
It can be technically faster to change a view itself if a) you have an icy grip on your design guide and b) you can keep all the people involved completely obedient to the design laws. In reality, the changes asked for in a view invariably affect all layers below it, all the abstractions built up in those intermediate layers, and usually involve all people who have say for every layer of your lasagna. Changing a view affects itself, the organisms in the view, the molecules that make them, the components beneath them, all while involving design, devs, project managers, sales reps, accessibility experts (and more) at every layer!
This is the ultimate issue with a computer law that I think everyone will recognize, but I can't find someone stating it in these terms, so I'm going to say it's my law:
Your abstraction is the wrong abstraction.
- Jim Schofield, 2026
Sandi Metz and Dan Abramov and Joel Spolsky have famously talked about how abstractions are almost always wrong, hard to get correct, and leak. It's often just easier not to have an abstraction.
If the focus of views is to address users' needs directly in the way they want and describe, let's not spend our time trying to create the perfect view to rule them all. In the past we had no other choice, but now we do.
Building abstractions at a high level like this is building a house of cards. The more you abstract up the ladder, the more fragile, time-consuming, and frankly, wrong, your abstractions become.
I would propose we are moving into a world where this old structure will be upended. When I design how features should work, the components of views that you see in a console or a dashboard or an account page will be structured more like this:
The components would be built, styled, maintained by engineers (with or without AI help) with an emphasis on stability and public API. The services would be designed by engineers, focusing more on the public API that the platform should provide. The schemas would make conceptual maps and code types for the view-generator (AI) to consume.
The view is then generated by trained models on demand, the same way we can get one-pagers from Claude.
Wait- don't we already provide contracts today? π
Yes. But the granularity of these contracts (maybe: the chosen abstraction level) is wrong. The reason one-pagers are so effective is that HTML, CSS, and vanilla JavaScript is just the right level to provide these views. This follows, I believe, from the "unreasonable effectiveness of text." We stay close to the HTML strings, not building smaller molecules or organisms unless AI finds it needs it, and it often won't.
The reason we lean on abstractions, platforms, and frameworks is because it helps us brush away unnecessary minutia and zero in on human-parsable design. These abstractions do help humans stand on the shoulders of giants to do greater things. We end up creating narrow and deep abstractions. This is where we are being trapped by our own limits as humans with finite memory and attention.
Leaning on a shallow and broad contract set allows infinite creativity and capability much like recursion unlocks infinite sentences in Chomskyan grammar.
Product groups and companies should develop a broad selection of shallow APIs and contracts π
And this goal would probably involve a lot of AI still. But much more architect-thinking and care is needed to provide the correct atoms of your platform. HTML is successful because there is a rock-solid set of specs that have been tirelessly vetted and argued over for decades. It maintains nearly complete backwards compatibility. It considers the public and private parts of the API for each element of the spec, and even considers how browsers should implement these things.
The real work for a system in a company is defining these. Engineers are not close to being replaced. The emphasis of their jobs is changing to architecture, design primitives, and setting up the structures so that they can be taken in and understood by AI.
What's funny about this is that this should have been the emphasis the whole time. Noticing the disposable nature of views just makes these fundamental pillars of software engineering blatant.
A model for UI post windows π
For a time UI was punchcards. We translated binary or assembly into punches in organized cards which were fed into a machine, and the machine would print out the output.
We then advanced to terminals, where we mostly used language commands to command a shell to do things, seeing the result printed in real time back to us on a screen.
We felt we mastered the UI when the mouse was introduced, the GUI was made the official operating system default, and we modelled our computers around documents and folders on a desktop and windows. We then ported this to mobile displays where we can touch, drag, tap, and pinch our views.
All of this was necessary, but now we're at the last step in the UI evolution: the conversation.
I don't mean to suggest I'm the futurist who came up with this grand prophetic understanding. Many people are saying it.
The future of most UIs is a conversation with an AI that is enabled with functionality and the ability to produce artifacts. Here is a mockup of what I think most UIs will major on:
You probably are thinking "That's just any LLM interface." And I would say, "exactly." Claude and OpenAI and any of those other LLM interfaces basically converge on one effective interface. Product companies have not realized this is where they need to be yet.
You see, since the beginning of the internet, almost every application is CRUD, or a CMS. You create, Retrieve, Update, and Delete things. If you need to do anything more than that (the true functionality of your platform) you provide APIs, make views to expose those APIs, and hope that's what the customer needs.
We're past CMSes now. We do have CRUD APIs still, we're not getting rid of the functionality on your platform. But we're going to have consumers determine how they want to execute your functionality through immediately-generated views.
Why this, why now? π
About a year ago I was worried that AI would never get good at producing code. It has, and I've had to eat my words. It can produce more pristine and clear code than I can.
We have just reached a point where AI generated views can be assembled in a one-page HTML document with complete CSS styles and JavaScript functionality, and if we believe some of the analysis, agents don't really need to lean on frameworks the way humans do.
So we have a corollary from the thesis of this post: JavaScript frameworks are going to die.
Much in the same way jQuery is just not needed the way it was, or Babel is not needed in the same way- JavaScript frameworks are going to go as well.
Let's see what happens. I'm okay if I'm wrong, but if I were a betting man...
Conclusion π
I'm not going into the moral considerations of what happens to engineer jobs. I'm not going to talk about whether or not AI can actually be net good on society. There's so much more to flesh out and discuss as a consequence of thinking about the role of the engineer today.
But I hope this excites engineers and product developers and designers. The role we have is going to shift towards architecture, design, functionality, usability, and accessibility. We don't need to be dragged down by the heaviness of deep and narrow component libraries of component libraries of more component libraries. We can instead focus on a shallow and broad landscape to build things with, and watch LLMs rapidly iterate for us.
Let me know what you think. Find me on Bluesky or Mastodon. I also have an RSS feed here