History

Twenty-five years ago, John Gruber wrote a Perl script to make blogging easier. Today, that same plain-text format is how we orchestrate trillion-dollar AI models. In a recent conversation on the Naftiko Capabilities podcast, Anil Dash—who was there at the beginning—unpacks this unlikely journey and what it teaches us about building technology that lasts.

Dash's connection to Markdown runs deep. Back when he was doing what would now be called developer relations for Movable Type (the WordPress of its era), he helped shepherd Gruber's creation into the world. The premise was deceptively simple: recognize that people already use asterisks for bullet points and underscores for emphasis, then build a tool that transforms those conventions into proper HTML. No need to learn markup languages. No risk of breaking your site's formatting.

The late Aaron Schwartz beta-tested it. Developers immediately saw the value. And then, for a few years, it just quietly existed.

The real explosion came when GitHub and Stack Overflow adopted Markdown as their default formatting language. Because every developer on those platforms was exposed to it daily, they carried it into their own projects. It spread not through marketing or mandates, but through sheer utility and repetition.

What strikes Dash most, looking back with two decades of hindsight, is how Markdown's looseness—the very thing that made him "itchy" as a systems thinker—turned out to be its greatest strength. There were edge cases Gruber never specified. Ambiguities that a proper standards body would have ironed out. And yet that informality is precisely why Markdown survived while more rigorous efforts faded into obscurity.

Dash points to RSS as a counterexample. Around the same time Markdown emerged, RSS was the subject of heated debates about formal XML specifications and IETF submissions. People insisted on standardization. And none of it mattered. What actually worked was the "good enough" approach—run some conformance tests, make a profile that mostly works, and let people build things.

The lesson extends beyond technical specs. Dash reflects on his earlier career, when he celebrated enterprise adoption as validation. Microsoft's on board? Amazing. IBM's implementing it? We've made it. But that validation came with a cost: complexity. Suddenly the thing he could hack together by viewing source required a full weekend just to get running. The enterprise-grade version became impossible for regular developers to implement.

This pattern—what Dash calls the "expansion contraction cycle"—repeated with OpenID, OAuth, and countless other standards. The first versions were Markdown-style: simple enough that even a mediocre coder could implement them. Then they got "enterprised up," and accessibility collapsed.

There's an uncomfortable truth embedded in this observation. The bias toward technical correctness and formal standardization also makes it easier for big companies to capture standards. They're the ones with budgets to send people to standards meetings. They're the ones who benefit from enterprise extensions and subscription-based implementations. Maybe, Dash suggests, we don't actually want enterprise-grade versions of everything. Maybe "a little bit of a toy" is exactly right.

Artificial Intelligence

Which brings us to the present moment. Markdown has become what Dash calls "the control plane for AI." You can have the most advanced frontier model from a trillion-dollar company, and you're still making plain-text Markdown files to orchestrate it. You could be in Vim, using the most basic text editor imaginable, and that's how you're controlling cutting-edge machine learning systems. It's like Unix pipes, Dash suggests, but one layer up the stack—that pervasive, that fundamental.

The conversation turns personal near the end. Dash wrote his recent blog post about Markdown partly to remember Aaron Schwartz as a real person, not the mythology that's grown up since his death. To capture the funnier, pricklier version of someone who was genuinely wonderful but also genuinely human. And to remind people that the entire internet was built by regular people who, between asking about each other's kids and whether they'd planted their garden seeds yet, would view source and copy-paste their way to something useful.

That's how it was made. And that's how it could be made again.

For anyone building standards today—whether for APIs, AI context engineering, or whatever comes next—the Markdown story offers a counterintuitive playbook. Resist the urge to specify every edge case. Be suspicious of enterprise validation. Remember that the thing all these people use to make real things is more valuable than a line on your resume about billion-dollar adoption.

Sometimes the best technology is the one that stays a little rough around the edges.