The Word Content

If you want to do great work, the first thing you must do is stop calling it "content." A pipeline owner doesn't care if the infrastructure is pumping water, oil, or sewage. To the operator, the material inside is just volume. When makers use this word to describe their own output, they are unconsciously sabotaging themselves by adopting a structural constraint as a goal.

In software architecture, there is a concept called polymorphism where objects of different types are treated as instances of the same class. When you have an array of highly specific, complex objects like a cryptographic module or a custom rendering engine, you can downcast them to a generic base type. You do this so a stateless algorithm can process them in bulk without throwing an error. Calling your work content is literally downcasting human art into a generic base class. You take a highly dimensional object, strip away its unique properties, and flatten it so it can slide effortlessly through an aggregator's distribution pipe.

Why does this happen? The terminology did not originate with the people actually making things. We can trace the pathology back to executives viewing the early internet as a broadcast pipeline for monetization. In 1996, Bill Gates wrote an essay titled Content is King. The term was popularized strictly by tech executives to describe commoditized data intended for distribution. It is the vocabulary of the suits, not the hackers. To the executives building the early portals, the actual text or images didn't matter. They just needed something to put between the banner ads.

And when Web 2.0 aggregators arrived, they industrialized this perspective. To a platform's database, a deeply researched historical essay, a feature film, and a 15-second video of someone squirming in a TikTok dance are mathematically identical. They are simply a scalar value of user attention. The platforms flattened highly dimensional work for algorithmic convenience because they had to. A social media feed cannot parse nuance: it can only parse the generic base class. Martin Scorsese recognized this mechanical flattening of art when he pointed out that modern platforms treat a David Lean movie, a cat video, and a Super Bowl commercial as entirely interchangeable.

This makes perfect sense for the platforms. Because they own the pipeline, their primary structural incentive is to reduce friction. Friction occurs when an object has rough edges, and the roughest edge of all is highly dimensional human originality. When you normalize that originality into a flat array, you produce crap. The bizarre shift occurred when the makers themselves began adopting the aggregator's language.

      [ Content ]
          |
  +-------+-------+
  |               |
[Film]         [Essay]

The implication is that when you call yourself a creator of content, you are voluntarily accepting your role as a biological API feeding someone else's database. Michael Lynch diagnosed this in a post outlining why he refuses to use the term, noting that it represents the vocabulary of the middleman. You are describing your own labor from the perspective of the entity extracting the margin. It is like a cow describing itself as beef. When you do this, you signal to the market that your work has no inherent value outside of its ability to fill space in a feed. Independent-minded makers are beginning to realize they have been using corporate syntax to describe their life's work. A recent Hacker News thread about Lynch's piece highlighted this friction, with programmers and writers pushing back against the idea of their output being treated as mere packing peanuts for algorithmic feeds.

Language acts as a compiler for human behavior. In an object-oriented system, a specific subclass adds its own unique behaviors. A researched essay might contain complex logic to challenge assumptions. A film contains methods to evoke specific emotions. The base class of content just has generic methods for occupying space and generating engagement. When you cast the specific object to the generic base, the system can no longer see those specialized methods.

If you spend your days writing logic for the base class, you eventually stop writing the specialized methods entirely. Why compile complex functions if the environment is just going to strip them away? When you optimize your work to fit seamlessly through a generic pipe, you unconsciously stop doing the idiosyncratic things that actually make work great. You just build base classes. If you prune all the nuance out of your writing simply to fit a platform's schema, the result is going to be incredibly boring.

Let's look at the mechanics of this limitation. If you sit down to write an essay, you are trying to solve a specific problem in a specific domain. You might need weird formatting, or a strange tangent, or an entirely new vocabulary. The shape of the output is dictated by the idea itself, completely independent of what a feed expects. But if you sit down to produce content, your brain immediately references the platform's constraints. You ensure the hook happens in the first three seconds. You truncate the vocabulary so the engagement metrics do not dip. When you restrict your own intellect to satisfy a database, the final product is predictably bad.

You cannot produce elite work while treating your own output as a commodity. Human language dictates the ceiling of human quality. The instant you accept the establishment's vocabulary to describe your art, you simply become their employee.

So here is the choice.

You can either optimize for the specific, highly dimensional properties of the thing itself, or you can strip away all of that nuance to optimize for the distribution pipeline — a mathematical dead-end.

You just pick.

But if you build for the pipe, you are placing a strict mathematical ceiling on what you can achieve. You cannot create a masterpiece by treating it as volume.