I watched this Beyond tellerand talk by Matthias Ott and it really made me think. So much that I wrote this long blog post.
This is a bit of a niche rant that will only interest a very specific audience, but I wrote it, so I might as well publish it. Lately I’ve been having too much blog posts sitting in draft.
First of all, kudos to Marc Thiele for organising Beyond Tellerand all these years and for putting all the talks online. Very nice.
Now, about Matthias’s talk. I feel this talk could have been given 5 years ago.
Yes, the browser is the true grain – if you only consider the browser as a deployment target.
But design tools these days like Figma and Framer are gravitating towards supporting a visual environment to work with that grain. This talk is more or less ignoring that.
While I don’t disagree with the message to design and explore in the browser, Matthias is kind of ignoring that design tools are constantly evolving towards how the web works.
The standard way these talks seem to go is saying “haha Figma” “why a static picture?” and then showing designing in the browser as the way of the light.
I think that’s a very narrow view on design and creation.
These talks tend to mix up design and implementation completely. These talks are not talking about design – i.e. solving a problem in a visual manner through exploration and iteration. They are talking about implementation.
Talks like this forget that the process of web development where you are writing code and refreshing a browser hundreds of times to see what you are doing is not creation. It’s implementation.
The manipulation is indirect, which leads to highly uncreative results. One of my favorite conference talks is Inventing on principle.
In a way it’s difficult to compare this talk to Matthias’s talk, but it also talks about creation, and one of the points is that you need to be able to directly manipulate what you are creating in order to make good decisions. In a way, a fluid typography example in the browser that works across breakpoints is exactly that.
I miss some of that when I am designing in Figma. But when I am designing a fluid type scale, I am designing a very narrow slice of the whole thing I am designing.
Most examples shown in these kinds of talks are just implementation things. I’ve seen a type fluid scale and a subgrid a 100 times before. I did some of this in 2010 with Sass. I mean, they are good examples for beginners. And it’s good that there are better ways to do the same in 2025. But don’t try to posit that the web is the design tool.
It’s a way to visualize certain things that are a bit ahead of what traditional design tools can do.
While this talk is well-intentioned, and for any beginner designer it would be good to watch what Matthias is talking about and learn all the front-end techniques mentioned, this type of talk in my opinion fundamentally misunderstands what design really is.
This type of talk tries to posit that you can design in a browser and does it by showing a bunch of tech demos.
The reality is that you can’t actually design in a browser.
You can put things together, you can make disparate experiments, but in my opinion you will always need a free canvas to explore and iterate in a meaningful way.
You will need go through the design process, which has lots of bits and pieces and possibilities, where likely at some point you want to bring things alive in various ways – going towards a prototype. And that can be at any time in the process.
One of the great ways to make things alive could be an HTML/CSS prototype – but usually this is at the point that you already know what you are making (or you are iterating with AI, but that’s a whole other blog post 🤓).
It’s rather rare to see the act of creation truly happening from scratch in the browser. Who can really do that – and what are they making that is not an implementation of an idea created elsewhere?
In what Matthias is showing — fluid type scales, color logic with okclh, subgrid demos — in my opinion you are past design at this point – you are in the implementation world. This is a different world.
Many of the talk givers have roots in either web standards or accessibility. They work for browser vendors or as consultants have a vested interest in continuing to do what they do the way they do it.
If Figma, Framer of whatever design tool upends their job, it’s painful for them. If Framer ships a carousel component that makes every carousel on every Framer website accessible, there’s nothing more to report in an accessibility report.
If Figma Sites can generate the code that they like to write by hand, there is no selling of front-end development anymore. The reality I foresee is that something like Figma Sites and Framer will be used for small marketing sites, and at some point a big company outgrows that — and of course there is a need for real front-end development then.
My theory is that tools upending someone’s jobs gives them an almost visceral reaction to complain against the tool, not because it’s necessarily bad, but because it threatens their livelihood. I’ve seen a similar reaction to Figma’s AI features last year from designers themselves and it’s a bit funny to see the same thing this year.
Now it’s the front-enders and accessibility people that have their pitchforks up. The reaction to Figma Sites last week was especially stupid.
65 000 people watched Kevin Powell’s video taken from a livestream where 500 people gave a thumbs up to Kevin where Kevin thinks he is fighting the good fight.
But his whole video misses the point that you can set a custom tag in Figma. He complains about non-semantic div soup but he just simply missed one of Figma’s features. I feel like he should issue a bit of a correction to his audience.
He also gives an explanation to his massive audience about aria-label
that fundamentally misunderstands how aria-label works. It subsumes the content that’s inside, it doesn’t lead to duplicate reading of the content. I respect Kevin and his CSS teachings, but maybe he needs to read up on accessibility before making points like that?
People like Matthias Ott and his friend Matuzo then go on and applaud that kind of “haha” about the code that Figma sites generates. This part is in Mattias’s talk as well.
They go on and complain about the code structure that devs use today. Then they make a vague point about the cascade with references from when HTML and CSS was invented and then go on that the web was never meant this way. I’m sorry but that’s just repeating things that Jeremy Keith said 10 years ago without providing anything new.
You could clip in 10 minutes from an old Jeremy Keith talk into this talk and it would be exactly the same talk.
Maybe I am just getting old but I wanted to be presented with new information. Conferences are supposed to provide some new info, that take the current world into account, not regurgitate old stuff. Yeah, there is cascade in cascading style sheets.
And unfortunately the world has discovered that seemingly doesn’t seem to work for them and they gravitated towards Tailwind and component-scoped styles.
I also don’t like a gazillion Tailwind or typical CSS in JS output, and I’ve tried to fight the good fight against Tailwind (see this post and there’s many more if you search).
But on Tailwind, I’ve accepted it as something that people do. I can’t fight it anymore, because it’s become an accepted way of working.
These days I am more results-focussed: it it accessible? Is it performant? I won’t complain about the code structure, only about the result.
Look at X.com: if you look at the code if you open the browser dev tools you might have CSS in JS nightmares. But it’s one of the most performant and usable web apps out there for me. That’s what I am evaluating. (Now the Mastodon crowd will ready their pitchforks that I am still on X…)
Design tools are constantly evolving towards how the web works.
Check out how Framer is evolving for example. Framer has included rem font sizing since 2 weeks. Figma implemented aspect ratio for images since a few months. Figma just shipped grid at Config last week.
Through variables Figma can simulate dark/light mode in a visual environment. You can easily export those values to code for usage in the browser. If Figma ships okclh tomorrow, the argument of Matthias’s talk kind of disappears.
My point of view is that the shipping of features in design tools that correlate to browser features has been happening for years and is something that’s an absolute enabler for people to create.
Figma especially goes out of their way to make the primitive base of what they make transportable to the web. The engineers behind the new Figma draw went to great lengths to make sure the new dynamic stroke logic is exportable to SVG (see this tweet).
Then why bash them so much? They are doing engineering things that don’t even come close to the level of most consultant’s daily work.
Yet all they get is bashing from a specific community that doesn’t bother to fully evaluate the tool, then reacts to wrong information because it fits their world perspective. That’s confirmation bias in action.
The design tools are gravitating towards the CSS tech, and they do 90% of what you need in most projects anyway, so what’s the big point of taking a stance on designing in the browser?
Matthias says “CSS is the most powerful design tool for the web.” No, it’s the most powerful implementation tool.

The tech mentioned in the slides about CSS features is rather niche; most of what we needed was implemented between 2010 to 2020 in CSS.
Yet that slide is used as a main argument that designing in the browser is so much better of a design app.
What I mostly see are a bunch of technicalities. Yes, the browser has :where
and :has
but that’s just about selecting the right elements. That’s unrelated to design.
Sure, there’s a popover API now that half works: but I’ve implemented popovers since forever in my apps. And I could go on and give a similar example for everything on that slide (@supports
etc.). As I said earlier in this post, this is implementation, not design.
The extras that we are getting now on the web are mostly just a bonus and not fundamental. I can do just fine with hex colours.
The problem in most of my projects is NOT the color scale. It’s apps that are broken for users on a UX level. If I would make a Maslow’s hierarchy of needs for the apps I design, implementing okclh sits at the very top of the triangle.
During a certain part of the talk Matthias is showing us a color palette implemented in okclh. He is saying that this stuff is only possible to explore in the browser, where you are “painting with the web”. That’s a very narrow view.
First of all in the color blog post he is admiring, the tools showing the visualization were most likely not even written with web tech. They were done with all kinds of low-level tools and then converted to web code to visualize on the web. Yet Matthias paints a picture that this is ideation on the web.
I did similar work using a combination of Figma and scripting to map lightness scales to a uniform color space. Using python and chatgpt to get to a color ramp that is uniform (with hex). It was a pain – and I do agree that it’s nice to set up a color scale in okclh() directly in the browser.
Let’s say you are in a design project and you have to work with those colours, then it’s a bit lame that when you go back to design work in Figma, where you then have to recreate an incomplete picture. I agree in that sense that designing with static pictures doesn’t work — a main point of the talk — when the actual implementation target has different capabilities.
But once again, first of all the things he is talking about are quite niche, and next thing we know, Figma implements okclh(), and the argument that the design is a static picture that doesn’t represent the dev reality disappears.
Right now, we are evolving towards a situation where you can create what you used to need code for in a visual tool in an easy manner. For a certain kind of project — a small marketing site — you can skip the front-end development phase and go directly to these tools. Figma Sites is in beta and will likely evolve fast over the coming year. Framer is already usable today for this use case.
You can now hit publish in Framer to get to a real, high-end, responsive website with great fluid typography. I know this because we made a marketing site for a client with Obra just a few weeks ago and it took us way less time than it used to. I tested it for accessibility with Voiceover on my phone and it works just fine.
There is no bothersome front-end repo to maintain; no difficult CMS implementations. Just a visual tool and a publish button. In my mind, this is the future, where you pay a vendor to handle the annoying, repeated implementation parts for you.
Some of the crowd I follow om Mastodon would rather live in a world where they hand-code every detail. I think that’s fine from a craft perspective, and excellent for teaching, but a bit naive in the real world.
Anyway, that’s my perspective. In no way do I want to attack Matthias, I think it’s an excellent talk. I just find that he doesn’t use the work design in the right way, he is talking about implementation experiments in the browser. He also ignores how the design tools are growing towards the grain of the web, dismissing them with a static picture argument that was true in 2012, but not in 2025.