(Simon Willison) Why CSS Isn't Bloated: The Ambitious Design Language

# Why CSS Isn't Bloated: Understanding the Ambitious Scope of Modern Web Design

CSS (Cascading Style Sheets) often receives criticism from developers who view it as unnecessarily complex or bloated. However, this perspective misses the fundamental achievement of CSS: creating a unified, human-readable text format that handles an enormous range of visual, layout, typographic, and interactive challenges. Rather than being bloated, CSS represents one of the most ambitious technological achievements in web development history.

## Core Summary

- **CSS manages multiple complex domains** in a single language, including visual presentation, layout design, typography, animation, and digital interactivity
- **The scope of CSS extends far beyond what most developers realize**, handling everything from basic styling to advanced responsive design and state management
- **Criticisms of complexity often reflect misunderstanding** of what CSS is designed to accomplish, not failures in its design philosophy
- **CSS's flexibility and power come from its ambitious scope**, not from unnecessary bloat or poor engineering
- **Modern CSS features demonstrate continuous evolution** to address real-world design challenges while maintaining backward compatibility

## The Massive Scope That People Underestimate

CSS isn't just about colors and fonts. When developers call CSS "bloated," they typically focus on the number of properties or the learning curve required to master the language. However, they're often overlooking the sheer ambition embedded in CSS's design.

Consider what CSS attempts to do in a single, text-based format: it must handle **visual presentation** (colors, backgrounds, borders, shadows), **layout architecture** (flexbox, grid, positioning systems), **responsive design** (media queries, container queries), **typography** (font loading, text rendering, line spacing), **animation and motion** (transitions, keyframes, timing functions), and **digital interactivity** (hover states, focus styles, transitions between states).

Each of these domains represents a massive field of study in traditional graphic design, print production, and interactive design. CSS brings all of them together into one language that must work across billions of devices, browsers, screen sizes, and user contexts. The fact that CSS attempts to express "the totality of visual presentation and layout design and typography and animation and digital interactivity" in a human-readable text format is not a sign of bloat—it's a sign of remarkable engineering ambition.

When you compare CSS to proprietary design systems or specialized design tools, each handling only one or two of these domains, the achievement becomes clearer. CSS handles all of them simultaneously, in a format that developers can read, write, and modify with basic text editors.

## Why CSS's Complexity Reflects Its Reach

The apparent complexity of CSS directly correlates with its reach and capability. CSS doesn't just need to work for simple, static websites. It must power:

- **Enterprise applications** with complex dashboards and real-time data visualization
- **E-commerce platforms** handling dynamic content and user interactions
- **Media-rich websites** with video, animation, and high-performance graphics
- **Accessibility-first designs** that respect user preferences and assistive technologies
- **Responsive experiences** adapting to devices from smartwatches to 4K displays
- **Animation-driven interfaces** that guide users through complex interactions
- **Dark mode and light mode implementations** that preserve user preferences
- **Progressive enhancement strategies** that gracefully degrade across browser capabilities

Supporting all of these use cases requires a broad feature set. CSS properties like `display`, `position`, `grid-template-columns`, `transform`, `animation`, and countless others exist because real-world design challenges demand them. Removing them wouldn't simplify CSS—it would cripple it.

The feature set isn't bloat; it's evidence of CSS's success in addressing genuine user and developer needs. Each property exists because developers built something that required it.

## The Human-Readable Achievement

One of CSS's greatest accomplishments often goes unappreciated: it remains human-readable while handling such enormous scope. 

Compare CSS to its alternatives. In the early days of the web, visual styling was either hardcoded into HTML or managed through complex procedural graphics. Designers and developers had limited options. CSS emerged as a declarative language—you describe what you want, and the browser interprets it. This approach is fundamentally more accessible than procedural or imperative alternatives.

Look at a modern CSS rule:

```css
@media (min-width: 768px) {
  .hero {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 2rem;
    align-items: center;
  }
}

This is readable. It expresses complex layout logic in plain language. A developer with minimal CSS experience can understand what this code does. Compare this to writing equivalent layout logic in JavaScript or graphics programming, and you'll appreciate CSS's elegance.

The fact that CSS can express such sophisticated concepts—grid layouts with responsive behavior, alignment, spacing, and media-based conditions—all in human-readable syntax is a testament to thoughtful language design, not bloat.

Modern CSS: Continuous Ambition

CSS hasn't stopped evolving. Recent additions like CSS Grid, CSS Custom Properties (variables), container queries, and cascade layers represent the language pushing into new territory:

• CSS Grid solved fundamental layout problems that were previously impossible to address elegantly
• CSS Custom Properties brought variable management and dynamic theming capabilities to native CSS
• Container queries enabled components to respond to their container size rather than viewport size
• Cascade layers added explicit control over specificity and cascade order, solving long-standing maintainability challenges

Each of these features adds capability. Yes, they add complexity for developers trying to learn everything at once. But they also dramatically expand what CSS can do, enabling more maintainable code and more sophisticated designs.

The criticism sometimes heard—"CSS has become too complicated"—often conflates two different problems:

1. Learning CSS fundamentals remains straightforward. Basic syntax, the cascade, inheritance, and simple selectors are approachable.
2. Mastering advanced CSS features requires study and practice, just like mastering any powerful tool.

This distinction matters. CSS doesn't need to be simpler for beginners; it needs to be clear in its fundamentals. And it is. What's changed is that as developers' ambitions grow, they reach for more advanced CSS features. That's not a flaw; that's a tool growing with its users.

The Respect CSS Deserves

Eric Meyer's perspective—that CSS deserves respect for what it attempts to accomplish—reframes how developers should think about the language. CSS isn't bloated; it's reaching. It's ambitious. It's trying to solve design problems across an incomprehensibly large range of contexts and devices.

Yes, CSS can be frustrating. Yes, there are aspects that could be better designed. No language is perfect. But frustration sometimes comes from CSS not doing something impossible, or from expecting CSS to work in a context where it was never designed to work. More often, frustration comes from not yet understanding how to leverage CSS's features effectively.

The alternative to "bloated CSS"—a simpler language with less capability—would create a different set of problems. Developers would reach for preprocessors, JavaScript frameworks, and workarounds to accomplish what modern CSS now handles natively. That's not a better situation; it's a regression.

Conclusion

CSS isn't a bloated mess. It's an ambitious, evolving language that attempts something genuinely difficult: expressing the complete scope of visual presentation, layout, typography, animation, and interactivity in a human-readable format that works across billions of devices. The breadth of CSS's scope isn't a design flaw—it's a design achievement. When developers encounter CSS's apparent complexity, they're not looking at bloat; they're looking at the price of ambition. And that price, historically speaking, has been more than worth paying. Respect the platform that powers the visual web.

---

> Original source: [A quote from Eric Meyer](https://simonwillison.net/2026/Feb/15/eric-meyer/#atom-everything)
>
> powered by [osmu.app](https://osmu.app)