The Function Explosion Nobody Asked For
CSS @function is coming, and honestly, I'm torn about it. On one hand, the ability to write reusable logic directly in stylesheets sounds amazing. On the other hand—I'm not sure this is the right move, but—we already have custom properties, preprocessors, and component libraries doing similar work. Adding functions to CSS feels like we're building a programming language where a styling system should live.
But here's the thing: when you're building something like Figma's design system or a complex product dashboard, having computed values, conditional logic baked into CSS itself? That's powerful. I've spent too many nights wrestling with CSS variables and calc() trying to recreate what a simple function would do in seconds.
- Functions mean less JavaScript. Fewer DOM mutations. Better performance when you're rendering thousands of components.
- Testing gets harder
- The specificity nightmare we already have will probably get worse before it gets better, though I could be wrong about this entirely
alpha() and the Colors We Didn't Know We Could Have
The alpha() function is quieter than @function but honestly more immediately useful. Being able to adjust opacity programmatically without creating seventeen versions of the same color value? That's the kind of thing that makes you want to refactor your entire color system at 2 AM.
I'm not sure this is the right move, but I actually think alpha() might replace a chunk of our rgba() usage sooner than we expect. Except rgba() isn't going anywhere. We'll probably have both for five years while developers argue about which is "correct."
What matters to me in custom products: this means fewer CSS variables devoted to color states. If you've built a design system for an SaaS platform, you know the pain. You have primary-color, primary-color-hover, primary-color-disabled, primary-color-visited... alpha() lets you compute those on demand.
Grid Lanes and Dialog: The Features You Missed
Grid Lanes sound like they're solving a problem I didn't know I had until I read about them. Better organization. More readable template areas. Layout without the mental overhead of subgrid.
Dialog elements, though—now that's interesting. Most developers don't know you can style ::backdrop independently, or that focus is automatically managed, or that the return value actually works like a form submission. I built three custom modals before realizing the native Dialog API handles accessibility concerns I was solving manually with ARIA attributes.
Still annoyed I didn't discover this sooner.
CSS Wordle Exists and I Have Questions
There's a Wordle game built entirely in CSS. Five guesses. Color feedback. It works.
But should it? This is where I genuinely don't know if we've crossed into clever territory or absurd territory. It's an excellent demonstration of what's possible. It's also a reminder that just because you can solve a problem with CSS doesn't mean that's the best solution. The mental energy required to maintain that codebase would be brutal. I'm not sure this is the right move, but from a pure showcase perspective—building something for a portfolio, proving you understand the language deeply—it's undeniably impressive.
Most of my client work doesn't need this level of CSS complexity. But maybe the next one will.
What This Means For Product Work
Building custom web products means staying ahead of these features. Not because we'll use them immediately, but because they shift what's possible in the performance and UX space.
@function could eliminate CSS-in-JS dependencies for smaller projects. alpha() changes how we think about color systems. Grid Lanes might actually make responsive layouts less painful. Dialog forces us to reconsider modal patterns we've been repeating since 2016.
The weird part? These features are still experimental. You can't ship them to production yet unless you're targeting a very specific browser landscape. Most teams are still wrestling with browser support for things that landed two years ago.
So we watch. We experiment in side projects. We wait.
And somehow, CSS keeps getting more interesting while also becoming harder to master completely.
