Is Python the New Assembly?

I keep thinking about compilers. The old ones—1950s.

Back then, engineers spent their days manually managing memory addresses and CPU registers. Assembly was the craft. Every instruction mattered. Then high-level compilers arrived—and many resisted.

“You’re giving up control,” they said. “Real programmers write assembly.”

Fast forward to today: nobody thinks about the assembly their compiler generates. We trust the abstraction. We focus on the logic.

What if we’re at that same inflection point again?

The Parallel That Keeps Nagging Me

I’ve been sitting with this idea for months now. Wrote a whole whitepaper on it because the implications felt too big for a blog post.

The thesis is this: just as we stopped worrying about how print("hello") becomes MOV instructions, we may be entering an era where Python, Java, TypeScript—the languages we consider “high-level”—become the new low-level output.

The machine handles syntax. We handle intent.

Which sounds elegant. Except.

The Evidence Is Messier Than the Narrative

There’s real evidence pointing toward inevitability. MCP went from 100,000 to 8 million server downloads in under a year. Cursor hit a $2.6B valuation. The Model Context Protocol is now an industry standard after just 12 months.

But then there’s the METR study. The most rigorous RCT on AI coding productivity. Their finding?

Experienced developers using AI tools were 19% slower.

Not faster. Slower.

And here’s the kicker: the developers thought they were 20% faster. Their perception was wrong.

So Which Is It?

I’ve gone back and forth on this.

One day I’m convinced we’re watching the end of syntax as a core skill. The next day I’m debugging AI-generated code and wondering if any of this is actually progress.

Here’s what I think is actually happening—at least today:

Vibe coding failed. The “accept all, ship it” approach produced production disasters. 16 of 18 CTOs in one survey reported AI-caused outages. James Gosling called it flatly: “Not ready for enterprise because software has to work every fucking time.”

But the abstraction isn’t failing. What’s failing is unstructured AI assistance. Accepting outputs without inspection. Treating the model like magic instead of a tool.

The transition from assembly to C wasn’t just “let the machine handle it.” It was the creation of new governance structures—type systems, compilers, linkers—that made the abstraction safe.

We’re not there yet with AI. But we’re building toward it.

What Changes If This Is True

If Python really is becoming the new assembly—and that’s still an “if”—then a few things shift:

The skill ceiling moves. Syntax fluency becomes table stakes, like knowing how to use a search engine. The differentiator becomes specification precision—the ability to articulate what you want with enough clarity that the machine can execute safely.

Technical debt transforms. In a world of disposable, just-in-time software, we don’t maintain codebases—we regenerate them. The question isn’t “how do we maintain this?” but “can we regenerate it when needed?”

New roles emerge. Not “prompt engineer” (that’s already obsolescing). Something more like… product manager meets systems architect. Someone who maps business intent to technical capability without necessarily writing the implementation.

The whitepaper calls this the “Intent Architect.” Whether that label sticks, I don’t know. But the function is real. I see it in my own work every day.

The Question I Can’t Answer

Do you remember the last time you thought about assembly?

Probably not. Most of us don’t. The abstraction layer ate it so completely that it became invisible infrastructure.

Will we eventually “forget” how to write Python the same way we forgot assembly?

I don’t know. Part of me thinks the abstraction can never be total—that human judgment at the implementation layer will always matter. The METR study suggests that’s true today.

But another part of me remembers that people said the same thing about compilers in 1957.

---

The full breakdown—with all the evidence for and against, the MCP adoption data, the productivity paradox, the economic implications for SaaS—is in The Dissolution of Syntax.

I’m curious where you land on this. Are we at a phase transition? Or is this just another round of “AI will change everything” that underdelivers?

Either way, I’m not betting against the abstraction. I’m just not pretending it’s finished.