The Unstoppable Evolution of CSS into Everything

Level 1: One Tool Does It All

Imagine you have a simple tool – let’s say a paintbrush that you use to color your drawings. Now picture that over time, this paintbrush starts gaining magical new abilities. First, it learns how to do math and measurements, so it can help you draw perfect circles and angles without you doing any hard calculations. That’s pretty cool, right? Later on, the paintbrush can actually make decisions: if it senses your drawing is too dark, it automatically switches to a lighter color. It’s almost like it has a tiny brain now. A few years go by, and your paintbrush doesn’t just help with art – it starts doing your homework and managing your chores. You come home and the paintbrush has cleaned your room and organized your stuff. Unbelievable! Finally, imagine that in the far future this paintbrush becomes so powerful that it can run your entire house. It can cook dinner, it can turn the lights on and off, it can even build more smart tools by itself. It’s as if everything you need is being handled by this one super paintbrush.

Sounds crazy, doesn’t it? That’s exactly the joke of the comic. In real life, CSS is like that original simple tool (a language just for styling webpages). The comic pretends that CSS keeps getting new powers, a bit like our magical paintbrush. The developers in the panels are celebrating each time CSS gains an ability that normally belongs to some other tool. By the end, they’re shouting “Everything is CSS!” – meaning their one tool now does it all. It’s funny because it’s so exaggerated: something meant for a small job growing into the only thing you’d ever need. The feeling is similar to how a kid might joke, “One day my pencil will do my homework for me!” We know that’s not really going to happen, and that’s why we laugh. The comic uses that same kind of playful exaggeration for web technology, and the excited people cheering in each scene make it even sillier and more fun.

Level 2: From Styles to Servers

Let’s break down the comic in simpler terms, focusing on what CSS is and how these changes stack up. CSS means Cascading Style Sheets, and it’s the language used to make websites look nice. If you have an HTML page (which has the content and structure), CSS is what you write to set the colors, fonts, layout, and overall design. For example, you can use CSS to say “make all headings blue” or “put a 20px margin around this element.” It’s all about presentation. Importantly, CSS by itself is not like a regular programming language – it doesn’t have things like loops or if-statements where the code can make decisions or iterate. It’s mostly a list of style rules that the browser applies to elements.

Now, in the first panel of the comic (tagged “March 2019”), the developers are excited that CSS will support trigonometric functions. Trigonometric functions are math functions like sine (sin) and cosine (cos) that come from geometry (they’re used to relate angles to ratios of sides in a triangle). Why would that matter for CSS? Well, sometimes when designing fancy layouts or animations, you might want to calculate positions in a circle or wave. For instance, imagine you want to spread out elements evenly on an arc – you’d use sine and cosine to compute the coordinates. Before, you’d have to use JavaScript to do that math and then feed the results into CSS (or pre-calculate values). The news that CSS itself could do sin() and cos() means the browser’s CSS engine can directly calculate those values when rendering the page. So the dev in the strip is basically saying, “Hurray! We can let CSS do some math for us now, so we don’t need a script for those calculations.” This was a real change being discussed around 2019 – adding a bunch of math functions to CSS. It’s part of a trend to make CSS more powerful and self-sufficient for design tasks. The second developer’s “Ah…” might imply “finally, but I’m not that excited” or “I’m not sure how I feel about this,” which is a bit of foreshadowing of the comic’s humor (some folks don’t share the same level of enthusiasm for every new feature).

Moving to panel labeled 2020: The team is cheering because “we can do loops and conditionals in CSS!” Loops and conditionals are fundamental concepts from programming. A loop (like a for loop) lets you repeat a set of instructions multiple times. A conditional (an if statement) lets the program decide to do something only if a certain condition is true. For example, in a normal programming scenario, you might say “if the user is logged in, show a logout button, otherwise show a login button” – that’s a conditional decision. And a loop might be “create 10 cards, one for each user in this list” rather than writing the style for each card by hand. Standard CSS doesn’t have these structures. If you write CSS, you can’t tell it “repeat this rule 5 times” or “if the screen is bigger than 1000px wide, then apply these styles” (well, CSS has media queries for responsive design, which is a limited kind of conditional based on screen size, but not a general if-else for any condition you want).

So why are they excited about loops and conditionals in CSS? Because it would make CSS much more dynamic and reduce a lot of repetitive work. Right now, developers often use CSS preprocessors like Sass or Less to get around CSS’s limitations. These are basically tools/languages where you do have loops, variables, and conditionals. You write in Sass (for example, you might loop to generate a bunch of CSS classes programmatically), and then you compile that Sass file into a normal CSS file that the browser can understand. It’s a workaround that’s become very common in frontend development. So if CSS itself introduces loops and conditionals, it’s like cutting out the middleman. You wouldn’t need a preprocessor or as many hacky tricks; you could do a lot more in plain CSS. For a junior dev, think of it this way: originally CSS is like a calculator that can only do addition and subtraction, and we’re super excited that they might upgrade it to do multiplication, loops, and maybe a simple “if” decision – it opens up many possibilities.

Now, so far so good – those first two panels are about CSS gaining capabilities that sound programmatic (math and logic). The next jump, though, is into crazy territory (which is where the humor really ramps up). The panel marked 2025 imagines that CSS 8 (they’re using version numbers humorously – in reality we don’t label CSS versions that way anymore, but let’s go with it) can run on the back-end and store data. The back-end refers to the server side of a website or application – the part that runs on servers in a data center somewhere, dealing with the business logic, talking to databases, handling user authentication, etc. For example, when you log into a site, the back-end code checks your credentials against the database. Typically, CSS is completely a front-end technology (it runs in your browser, shaping the look of a page). It has nothing to do with servers or databases. The comic jokingly suggests that in the future, CSS might become so powerful it can do server-side tasks too. There’s a specific callout: “We can get rid of Node and the database!” Node here refers to Node.js, which is a popular back-end runtime that allows JavaScript (normally a front-end language) to be used on the server. Getting rid of Node implies CSS would take over the work that JavaScript (via Node) does on the server. And getting rid of the database means CSS could somehow manage data storage itself.

To a new developer, this sounds almost nonsensical – and that’s the point, it is nonsense in a fun way. CSS doesn’t have any means to store data persistently or handle requests from clients. It’s like suggesting your paintbrush could suddenly also do carpentry; it’s a completely different job. The comic is parodying the idea of a “one-size-fits-all” technology. In the real world, we sometimes see overly optimistic claims like “This new framework can do it all, front to back.” Here they’re applying that exaggeration to CSS. So by 2025 in the comic’s imaginary timeline, CSS has evolved from a styling sheet into a full-blown programming environment that can run the whole website (both the part you see and the behind-the-scenes logic). It’s as if your CSS file is now a server application and a database as well. The developers are throwing a little party with hats and noisemakers because it’s such a wild milestone – they’re being facetious (sarcastic) by celebrating something that, in reality, is pretty absurd. The humor is apparent if you know that CSS on the back-end isn’t a thing; that contrast creates the comedic effect.

Now, the final panel (2035) goes completely over-the-top: “CSS 19 can auto-generate its own rules using AI and set up its own web server containers using a dedicated OS!” Let’s break that down piece by piece, because it’s packed with tech buzzwords:

• Auto-generate its own rules using AI: This suggests that CSS can write CSS. In other words, an artificial intelligence is built into CSS that analyzes something (maybe your content or desired design) and then produces additional CSS styles on its own. Today, AI and machine learning are used in tools that can help developers (like suggesting code completions, or optimizing some tasks), but those AIs are external tools or libraries, not part of the language itself. Here they’re joking that by 2035, the CSS spec might include an AI module out-of-the-box. If you imagine writing some basic styles and then CSS magically fleshing out the rest of the design intelligently – that’s the kind of scenario being teased. It’s the ultimate “smart” feature: the language doing the developer’s job. Sounds convenient, but also a bit like science fiction!

• Set up its own web server containers using a dedicated OS: This is even more far-fetched. A web server is software that serves web pages to users (like Apache or Nginx). A container is a method to package and run software in isolated environments (commonly using Docker containers in industry). And a dedicated operating system (OS) is basically saying an entire operating system tailored for CSS. So this part of the comic imagines that CSS can not only run on a server, but it can also handle deploying itself in a containerized environment and that there’s an OS whose primary purpose is to run CSS-driven servers. In simpler terms: think of an OS like Windows or Linux, but instead of being general purpose, it’s like “CSS OS” where the main thing it knows how to run is CSS code, perhaps to serve web pages. This is a playful jab at how software these days often runs in containers and how everything has an OS variant. It’s absurd because CSS is the least likely candidate to need its own operating system. Yet, if you’ve followed tech news, you’ll know there are niche operating systems (there’s an OS built around the web browser, there are OSes for specific languages). So the comic is just comically extending that idea: by 2035, why not an OS just for CSS containers!

When the character shouts “EVERYTHING IS CSS!”, it’s the grand finale of the joke. Up to now, each step was a bigger leap: CSS doing calculations, CSS doing logic, CSS doing server work, CSS doing AI and OS-level work. That final exclamation sums it up: everything in the tech stack has been subsumed by CSS. It’s a humorous exaggeration of the concept of one tool taking over all roles. In reality, we use different technologies for good reasons – each is specialized (databases for storage, server languages for logic, CSS for style, etc.). If one tool tried to do it all, it might do some things well and others very poorly. The comic isn’t seriously suggesting this will happen; it’s using hyperbole (excessive exaggeration) to make us laugh about the trajectory of CSS.

This relates to the idea of “feature creep”: that’s a term for when a product or technology keeps getting more and more features to the point that it might stray from its original purpose. Here, CSS’s original purpose was very focused (presentation and layout). With each “year” in the comic, CSS’s scope creeps outward – into computation, into programming logic, into backend, into AI and systems management. By the end, it’s unrecognizable (and ridiculously powerful). That’s why the comic is titled “the unstoppable feature creep of CSS.” It’s an exaggerated story of CSS’s evolution spun as a joke.

For someone new to web development, it’s also a lighthearted commentary on how fast things change. You might learn today “CSS can’t do X,” and then a couple years later, surprise, now it can! (For example, not long ago CSS couldn’t define custom properties—now it has CSS variables. It couldn’t do complex grid layouts easily—now we have CSS Grid, etc.) The comic takes that real phenomenon and pushes it to the extreme. It makes us imagine a far-fetched future where we only need to learn CSS because it does everything — which is amusing because right now, if anything, people often struggle to learn CSS alongside JavaScript, HTML, and backend languages. The idea of only CSS ruling them all is a funny reversal of the usual challenge.

In summary, this four-panel comic from CommitStrip is a satirical timeline. It starts semi-real (CSS gets math functions), then enters fantasy (CSS gains programming structures), and ends in absurd sci-fi (CSS with AI on its own OS). Each stage is celebrated by the characters as if it’s the next big breakthrough, which parodies the hype culture in tech. The categories like Frontend, WebDev, Languages, TechTrends are all touched on: it’s very much a web developer inside joke. You don’t have to know all the terms to get it — basically, it’s saying “what if the humble tool for styling websites kept growing until it could do every job in software?” It’s funny because that would never happen… yet every cheer in the comic sells it as the best thing ever. It’s a great example of tech humor making us laugh at the directions our tools could go if we got a little carried away.

Level 3: Feature Creep Cascade

For experienced developers, this comic hits on the humorous truth of feature creep in tech, especially in web development. It exaggerates how CSS has been accumulating features over the years and imagines a ludicrous trajectory if that trend went wild. Each panel amplifies a real-world pattern into satire. Let’s unpack why it’s funny (and a bit too real):

CSS learning new tricks: In the first panel (set in March 2019), the dev is excited that CSS will support trigonometric functions. This actually references a real development in web standards – around that time, proposals were indeed made to add math functions like sin(), cos(), and others to CSS. Frontend devs cheered this because it meant you could do things like rotations, oscillating animations, or geometry directly in CSS using math, without resorting to JavaScript. It’s a small feature in the grand scheme, but anyone who’s had to calculate angles or positions in the browser felt a bit of relief. The slouched colleague’s muted “Ah…” reaction in that panel is a classic comic foil: maybe he’s a tad cynical or just not easily impressed. That dynamic (enthusiastic newbie vs. seen-it-all veteran) is something a lot of dev teams have – one person hyping the new feature, another rolling their eyes because they remember the last ten “game-changing” features. It’s a gentle nod to how TechTrends and hype are received differently by different folks.

By 2020 (panel 2), the strip shows the team celebrating loops and conditionals in CSS. Now, in reality, as of 2021 CSS doesn’t natively have general-purpose loops or if-else constructs. But the comic is riffing on the direction things could go. Seasoned devs recognize this as a reference to features provided by CSS preprocessors like Sass/SCSS or LESS. Those tools have for years allowed us to use variables, loops, and conditionals when writing CSS, which then get “compiled” into regular CSS for the browser. For example, with Sass you might do something like:

// Using a Sass loop to generate repetitive CSS classes
@for $i from 1 through 3 {
  .col-#{$i} {
    width: #{ $i * 100px };
  }
}
// Sass would output:
// .col-1 { width: 100px; }
// .col-2 { width: 200px; }
// .col-3 { width: 300px; }

In plain CSS, you’d have to manually write those three classes or use another approach; Sass automates it. When the comic yells “Finally we can do loops and conditionals in CSS!”, it’s imagining that the CSS standard itself catches up with what these tools can do, eliminating the need for a preprocessor or for offloading logic to JavaScript. That’s a huge shift — it blurs the line between CSS and a full programming language. For veterans, there’s humor and horror in that idea: humor because we’ve joked in the past “hah, what if CSS had an if statement” (since CSS is notorious for lacking basic programming structures), and horror because part of us thinks “oh no, CSS is already complicated; adding programming logic could make debugging styles an even bigger nightmare!” It’s the classic mix of excitement vs. dread that accompanies powerful new features. We love the flexibility, but we fear the complexity.

Now, the 2025 panel dials it up. “CSS 8 can finally run on the back-end and store data! We can get rid of Node and the database!” This is where the comic goes from “somewhat plausible future” to “totally absurd… but parodying real trends.” As senior devs, we’ve seen this movie before with other tech: JavaScript, a language once confined to browser toys and image rollovers, became a serious back-end player with Node.js. Then JavaScript moved into databases (with things like MongoDB using JS in queries) and even native apps (Electron, React Native). The term “JavaScript everywhere” became a buzzphrase. So, when we see “CSS on the back-end,” it’s a clear lampoon of that “X everywhere” phenomenon. It’s funny because CSS is an even less likely candidate for back-end work than JS was – CSS has no ability to do calculations or disk I/O or networking. It’s as if someone said, “Well, we let JavaScript handle servers, why not CSS too?” and took it to a ridiculous extreme. The joke also touches on the evergreen hype of full-stack solutions. Companies and developers often fantasize about using one technology to handle the entire stack (to simplify development or because of personal preference). This comic plays with that by imagining a full-stack CSS developer who writes the client, server, and database logic all in CSS. It’s utterly impractical, which is why it’s comedic.

The line about getting rid of the database is particularly cheeky. Data persistence is not something you’d ever associate with CSS – CSS has no storage mechanism beyond perhaps the browser cache for assets. Yet here, they’re throwing out a database system (like MySQL, PostgreSQL, etc.) in favor of CSS storing data. It’s poking fun at those tech talks or articles that claim “XYZ will replace your database, your backend, and make lunch for you too.” We, as experienced developers, recognize that smell of hype. It’s the IndustryTrends_Hype the meme is tagged with. We chuckle because we’ve been through cycles where something was touted to replace everything else and solve all problems (only for reality to set in later). The bearded guy holding a coffee might be the stand-in for all the skeptical engineers thinking “Sure, let’s see how that works out.”

Finally, the 2035 panel just blows the roof off. AI-generated CSS rules! Containers and an OS dedicated to CSS! This is the kitchen sink of buzzwords and hype. By this time, if you’re a seasoned dev reading this, you’re likely grinning because the satire is obvious: it’s combining the hype of AI (“machine learning will write our code for us!”), the craze of containerization and cloud orchestration (“our CSS will deploy itself in a Docker/Kubernetes container — yeah, right”), and even the notion of custom operating systems (maybe a jab at things like Chrome OS or industry-specific OS projects). The character screaming “EVERYTHING IS CSS!” with confetti flying around is a caricature of that overzealous tech evangelist we’ve all met — the one who insists their favorite technology will eventually take over the entire world. It’s hilarious because we know people who are almost this passionate, though of course not about CSS taking over every layer.

That phrase “Everything is CSS” also satirizes the tendency to declare some tech as the ultimate solution. In the past, we’ve heard “Everything is an object” (OOP mantra), “Everything is a file” (Unix philosophy), “Everything is JavaScript” during the Node.js hype, or jokes like “Eventually, everything in programming becomes JavaScript.” Here it’s a front-end in-joke — CSS, often the humble stylesheet, is crowned king of computing. It’s ironic, too, because CSS is often considered one of the harder things to master in front-end (in an irritating way – many devs have struggled with CSS quirks). The idea of it running its own AI and OS is both frightening and amusing to those who’ve wrestled with a float clearing or a flexbox glitch. If you’ve spent hours debugging a CSS layout, the notion of debugging a CSS-powered server or (heaven forbid) a CSS kernel is both absurd and terrifyingly comedic.

This comic also nods at the concept of language evolution and how communities react. When new CSS features (like CSS Grid, Flexbox, or custom properties) came out, there was genuine celebration in the front-end world — blog posts, tweets, conference talks galore. Each time, someone proclaims “This changes everything!” The comic takes that celebratory atmosphere and cranks it up as the features get crazier. Seasoned devs see the tongue-in-cheek parallel to our reality: we do kind of throw mini-parties when a long-awaited feature lands (like when CSS Grid landed in browsers, people literally threw CSS Grid celebration events). So by the time AI Stylesheets are a thing, of course there’s confetti and champagne — it’s the ultimate sarcasm about our tendency to over-hype.

There’s also an undercurrent of satire about complexity. We who have been in industry know the saying “With great power comes great responsibility – and complexity.” CSS starting as a simple thing and ballooning into an AI-driven, container-managing monster is a tongue-in-cheek warning. It echoes the joke, “Any sufficiently complicated app contains an ad-hoc, bug-ridden implementation of half of a programming language.” Here, CSS literally implements not just half a programming language, but practically every aspect of computing. Experienced devs find that both funny and ironically plausible – not that CSS will do it, but we’ve seen other tools bloat beyond their scope. Think of modern web browsers: they started as document renderers and now they are practically operating systems running apps in tabs. Or consider how Excel (a spreadsheet tool) grew to have scripting and turned into a programming platform for some businesses. This comic is essentially laughing at that slippery slope.

In summary, the humor at this level comes from recognizing those patterns and absurdities. Frontend humor often involves poking fun at how far things can be taken (framework wars, new language features, etc.). The tags like css_feature_creep and css_everything say it all: it’s joking about CSS’s feature creep till it does everything. As a senior dev, you chuckle because you know CSS’s past and present, and the joke extrapolates that into a crazy future. It’s both a celebration (we do love new CSS toys) and a parody of the WebDev hype cycle. After all, who among us hasn’t joked in frustration, “ugh, at this rate, in 10 years, will be doing my whole job for me.” This CommitStrip just made that joke explicitly about CSS. It’s a high-five to all of us who have lived through the evolutions of web tech and come out the other side with a sense of humor about it.

Level 4: Turing-Complete Cascade

At the deepest technical level, this comic pokes at the theoretical limits of what a language like CSS can do. Initially, CSS (Cascading Style Sheets) was a domain-specific language – it was purpose-built to describe presentation, not to perform computations or make decisions. It’s traditionally declarative, meaning you write rules for styling and the browser applies them, without any loops or conditional logic in the CSS itself. However, when the developer in the first panel cheers about adding trigonometric functions (like sin() and cos()), they’re hinting at CSS moving beyond pure styling into the realm of computation. Trigonometric functions are part of math normally handled in JavaScript or other programming languages. Their inclusion in CSS means the style sheet can now compute values (e.g. smoothly animating an element in a circle using cos() and sin directly in CSS). This is a big philosophical shift: CSS is adopting capabilities of a programming language.

From a theoretical computer science perspective, the mention of CSS getting loops and conditionals (panel 2) is even more profound. Loops (for, while) and conditionals (if/else) are the building blocks of algorithmic logic. In formal terms, adding these could make CSS Turing-complete – meaning it would be computationally universal, able (in principle) to perform any calculation that a Turing machine can, given enough time and memory. Turing completeness is a concept from automata theory that indicates a system can simulate any other computational system. Classic CSS intentionally fell short of this – it has no way to do an infinite loop or arbitrary computation, which is one reason CSS can’t get “stuck” running code the way a script might. By design, applying CSS to a page should always terminate quickly (it’s mostly just matching selectors and assigning styles). But if you introduce things like loops or complex logic into CSS, you start needing to consider issues like non-termination (could a bad CSS rule cause an endless loop of style generation?) and complexity of evaluating styles. This veers into the territory of the Halting Problem – if CSS becomes a general-purpose language, determining whether a given CSS snippet will finish applying or run forever could become undecidable in the general case. Essentially, you’d be converting a simple styling system into a form of programming where all the classic computation pitfalls (infinite loops, heavy algorithms) could arise. That’s a mind-bending shift for something originally as simple as a stylesheet.

The comic then pushes beyond Turing completeness into total domain takeover. By 2025, it jokes that “CSS 8” can run on the backend and store data, replacing a Node.js server and a database. This implies a runtime where CSS files aren’t just static resources but are executed like scripts on a server. It’s a whimsical inversion of reality: historically, we saw JavaScript (another front-end technology) migrate to the server side (with Node.js) and even desktop apps, effectively making JS a full-stack language. Here we imagine CSS following suit. For CSS to manipulate data or handle requests, it would need an interpreter or engine on the server that reads CSS and performs actions – essentially treating CSS as code rather than style. Theoretically, one could design an interpreter where CSS selectors and rules trigger server-side behaviors (it sounds bizarre, but so does running JavaScript on the server before Node existed). And if CSS can manage a database, that implies giving it some form of I/O and data persistence ability. At that point, CSS isn’t just a stylesheet; it’s a programming language with a data model and perhaps state. We’re talking about turning a presentation language into a full-fledged general-purpose language. It’s as if the separation of concerns principle (content vs. presentation vs. behavior) has been completely collapsed into CSS doing all three. This is a humorous nod to how web architecture might look if a single technology subsumed all layers.

By 2035, the comic goes fully tongue-in-cheek: “CSS 19” can auto-generate its own rules using AI and even set up its own web server containers with a dedicated operating system. This is an absurd, ultimate endgame of feature creep. It suggests an AI component built into the CSS engine that can write new CSS rules on the fly – effectively CSS becoming self-writing or self-optimizing. Modern AI (like machine learning models) can indeed assist in code generation (we have tools now that suggest CSS based on design inputs, for example), but weaving that into the language’s core would be an architectural marvel (or nightmare). Moreover, if CSS is launching containers and has its own OS, it implies that CSS has taken over not just the application layer but the infrastructure layer of computing. An OS is low-level software that manages hardware and runs other programs – for CSS to have its own OS, the joke is that everything from the metal up to the user interface is now ruled by CSS. We’re basically imagining a world where a web stylesheet language is the central orchestrator of computing resources. Technically, that would mean implementing network sockets, file systems, process scheduling, etc., all via a CSS-centric system. It calls to mind projects like Chrome OS (essentially a browser-centric OS) or jokes about text editors that become operating systems. Here the stylistic language is the OS – a hilarious inversion of the usual hierarchy.

Underneath the humor, there’s a genuine computer science theme: many systems over time accrete features until they’re equivalent to a general computing platform. We’ve seen accidental Turing-completeness crop up in unexpected places – from SQL extensions, to spreadsheets, even to esoteric uses of HTML/CSS combined with form inputs. There’s an old saying that any sufficiently sophisticated software system will end up implementing a poor copy of Lisp (a very powerful programming language) if pushed far enough. This comic embodies that concept: CSS was never meant to be a programming language, but we’re imagining it gradually morphing into one, and eventually into the only one. It satirically highlights the feature creep in language design – how languages grow more complex and closer to general-purpose to satisfy new demands.

Finally, consider the theoretical implications of an “everything is CSS” world. If literally all aspects of an application were done in CSS, you have a single language system. In theory, that simplifies tooling (one unified technology), but it concentrates a lot of responsibility and complexity into that system. It’s like a unified field theory of web development, which in practice might be unmanageable. Computer scientists might compare it to a Turing tar-pit scenario. In a Turing tar-pit, a system is theoretically capable of anything (because it’s Turing-complete), but doing practical things becomes incredibly convoluted. CSS turning into an all-powerful language would be exactly that – you could do everything with it, but imagine how awkward writing something like a database query or a multi-threaded server in CSS would be! The quote below famously captures this pitfall:

“Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.” — Alan Perlis

In other words, just because CSS could evolve to do anything doesn’t mean it’s a good idea. The comic revels in that absurdity, using the theoretical extremes of computing to get a laugh out of anyone who knows what it would mean to make CSS a god-language of the stack.