Alright, let's talk CSS. It's a topic that often brings out strong opinions, and frankly, a good deal of prescriptive dogma. That's why I found Jens Oliver Meiert's forthcoming piece, titled "There Is No “Wrong” in CSS," particularly interesting. Slated for publication on SitePoint on March 16, 2026, Meiert isn't just making a statement; he's challenging an entire mindset prevalent in web development. This article promises to cut through the noise, arguing that the very idea of "wrong" CSS is largely a myth.
Meiert, a familiar name in web standards discussions, points out what many of us have encountered: a constant stream of advice from peers telling us what we "must" or "must not" do with our stylesheets. If you've been in this space for any length of time, you'll recognize the pattern. It's an environment where opinions solidify into perceived best practices, often without a full appreciation for context or outcomes.
Challenging the Dogma
Here's the thing: while intentions are usually good, this kind of absolute thinking often stifles creativity and problem-solving. Meiert's article highlights several classic examples of these supposed "rules" that developers are regularly told to follow or avoid.
Consider the perennial debate around CSS resets. Some insist
you absolutely *have* to use them to ensure cross-browser consistency. Then there's the notorious `!important` rule, which many gurus decree
*never* to employ, despite its legitimate use cases in specific scenarios. Similarly, there's a contingent that cautions
against using shorthand properties, preferring longhand for clarity, and advice to
sidestep certain selectors entirely. More recently, the push has been to
exclusively adopt logical properties.
What's telling is that the article uses general search links for these topics rather than linking to specific manifestos. That suggests the "wrong" arguments are so widespread and varied they don't trace back to a single source, but rather a collective consciousness within the developer community.
A Pragmatic View of Code
Meiert's core argument implies a more pragmatic approach to CSS. If the code achieves the desired visual outcome, is maintainable, and doesn't create accessibility barriers, then its adherence to arbitrary stylistic purity tests becomes secondary. The article is pushing back against a culture that sometimes prioritizes rigid, opinion-based standards over functional results. As a journalist, I'm inclined to agree. When it comes to writing code, especially on the front end, "it works" should often be the primary validator, not how closely it conforms to someone else's idea of perfection. It's a reminder that effectiveness should trump dogmatism.
It’s an interesting notion, the idea that "you can’t write wrong CSS." As someone who’s spent years sifting through web projects, I can tell you it often *feels* like we do, doesn't it? The author of this piece, for one, readily admits to writing what they consider "wrong CSS" in their own career, pointing to examples involving
CSS resets,
`!important` declarations,
shorthands,
selector performance, and
non-logical properties.
Yet, this article then pivots, presenting a compelling case for why, from a broader perspective, the concept of "wrong CSS" isn't as clear-cut as we might think. It’s a subtle but significant distinction that challenges how we evaluate our styling choices. The author outlines four core arguments, and honestly, they make you rethink some long-held assumptions.
The Pragmatic Approach: If It Works, It Works
First up, the most obvious point: if your CSS delivers the desired outcome without any tangible drawbacks, then it simply *works*. There’s no practical disadvantage, no significantly worse user experience (UX), and certainly no concretely degraded developer experience (DX). If it ain't broke, don't fix it. CSS, after all, isn't meant to be occupational therapy for developers; it’s a tool to build user interfaces.
What’s more, the very nature of the web platform supports this pragmatic view. It's built on a bedrock of backwards-compatibility, meaning deprecation is rare. Code written years ago often still functions today. As
Mark Pilgrim famously quipped, and it still rings true:
"Standards are like sex; one mistake, and you’re stuck supporting it forever!" So, if your styles work and don't actively cause harm, they're not "wrong"—they're just *there*.
Consequences Are Your Own Burden
Then there’s the argument that if your CSS causes problems, it’s fundamentally *your* problem. Consider a situation where your organization decides to expand into the Arab world, suddenly requiring extensive
RTL (Right-to-Left) script support. If your existing CSS isn't prepared for this, that's not a flaw in the concept of logical properties or a universal "wrongness" in your code. It's an issue specific to your project, your timeline, and your team's choices.
The responsibility, and thus the incentive to solve it, lies squarely with you. Your design decisions, your refactoring schedule – it’s all on your plate. This perspective essentially says: if the consequences of your styling choices don't ripple beyond your immediate context, then there's no inherent "wrong" to be found.
The Inherent Flexibility of CSS
CSS is incredibly adaptable. Say you've built a site using an older layout technique, like
float-based layouts, and you eventually decide it’s cumbersome. The beauty of CSS, unlike the more structural and harder-to-change
presentational HTML, is its inherent mutability. You can pivot. Making significant layout changes in CSS, while not trivial, is generally a far simpler undertaking than re-architecting your underlying HTML.
"Easy" is a relative term here, of course, and project-specific testing cycles can certainly add complexity. But the core point stands: CSS allows for rapid iteration and fundamental changes to presentation. If a better solution emerges, or a new requirement demands it, you *can* make the switch without tearing everything down. It's hard to label something as "wrong" if it's so readily correctable. We already know the real imperative is to
"get the HTML right"; CSS offers more forgiving ground.
When Barriers Become a Platform Responsibility
This fourth point is perhaps the most thought-provoking, pushing us into territory that’s more aspirational than current reality. The author suggests that if your CSS creates genuine barriers for users—think accessibility issues that truly hinder access—then this *should* be seen as a failure of the web platform itself, not just "wrong" developer code. It’s a powerful idea: "The platform should make it hard to create barriers, and easy to remove them."
This isn't an official design principle of web standards, not yet anyway. But what if it were? It aligns with the philosophy expressed by
Joe Clark years ago:
“if a browser or adaptive technology can or should handle an accessibility issue, I won’t.” The implicit contract is that "The developer provides the intent; the platform provides the guarantee of access."
Take something as extreme as black text on a black background—completely inaccessible and nonsensical. If this perspective gains traction, even that wouldn't necessarily be "wrong CSS" in an absolute sense. Instead, it would highlight a gap in the platform's ability to protect users. Perhaps through enhanced
user styles, automated color correction, or specific user-activated modes, the platform *could* or *should* intervene. We've seen developers struggle with issues like
smartphone notches and their
accompanying CSS solutions—problems that, by this argument, might well have been better handled at a platform level rather than pushed onto individual developers. It's an interesting direction to consider, and a conversation worth having.
I'm genuinely curious if this angle warrants a deeper dive in a future piece.
Navigating the "Wrong CSS" Accusation
So, what do you do when someone inevitably tells you your CSS is "wrong"? The advice here is refreshingly pragmatic: context is everything. First, figure out if their criticism even applies to your situation. If you're joining a new team focused on an international site that absolutely *needs*
logical properties for multi-script support, then yes, their advice to use them is sound and should be considered.
But if the context doesn't fit, then accepting that advice becomes *your choice*, not an obligation. This distinction—between genuine, contextual advice and rigid dogma—is key. It also offers a useful lens for moderating our own critiques of others' CSS. Is it truly "wrong" because it doesn't work, or because it doesn't align with *your* preferred methodology?
Ultimately, CSS provides a myriad of ways to solve design and interaction problems. The platform then dictates how these solutions are applied, exposed, and managed. Because of this inherent flexibility and the platform's underlying responsibilities, pinning down something as universally "wrong" in CSS becomes exceedingly difficult. The real takeaway is this: be adaptable, be pragmatic, and always consider the larger ecosystem.
*(Many thanks to
Ahmad Shadeed for reviewing this post.)*