Programming Languages Are Dead. The LLM Is the New CPU.

You’ve felt it, haven’t you? That quiet frustration every time you write a prompt, get a result, then realize you have to wrap it in Python, wire it through an API, handle edge cases in code, and pray the whole thing doesn’t fall apart in production. You’re not programming anymore. You’re translating — badly — between two worlds that were never designed to talk to each other.

The LLM doesn’t need a better Python wrapper. It needs its own assembly language.

That’s exactly what Linkly is attempting. And most people are completely missing the point.

Scroll through the comments on the Show HN post and you’ll see the usual chorus: “Can you explain more about this?” — the kind of polite confusion that happens when something genuinely new appears and nobody has the vocabulary for it yet. They think Linkly is just another DSL, another niche syntax for chaining prompts. It’s not.

Linkly treats the LLM as the hardware architecture itself.

Think about what that means for a second. Every programming language ever created — C, Rust, Python, JavaScript — was designed with a specific machine model in mind. Registers, memory addresses, instruction pipelines. The language is an interface to the hardware. But what happens when the “hardware” is a neural network? What happens when the runtime is probabilistic, not deterministic?

You don’t write code for a CPU anymore. You write code for a brain.

Here’s where it gets genuinely brilliant — and genuinely uncomfortable. Linkly compiles through MLIR, the same multi-level intermediate representation used in serious compiler infrastructure. That means it’s not some hacky prompt-chaining script. It goes through the same rigorous compilation pipeline that LLVM-based languages use. Deterministic compiler infrastructure meets fuzzy LLM semantics. That tension is the whole point.

The paradox is real: how do you build a language for something non-deterministic and route it through something deterministic? The answer Linkly proposes is radical — you let the compiler handle structure and optimization, and you let the LLM handle semantics and intent. Two layers, one language. The compiler doesn’t fight the fuzziness; it frames it.

If you build with LLMs, this should make your pulse quicken. Right now, your AI pipelines are held together with duct tape and hope. You write a prompt, hardcode it into a Python string, call an API, parse JSON, handle failures with try-catch blocks that were never designed for a system that might hallucinate a completely different schema on Tuesday. You’re using 1970s tools to manage 2024 intelligence.

The tools weren’t built for this world. Stop pretending they were.

Linkly’s bet is simple and enormous: the next low-level language isn’t for silicon. It’s for neural networks. When you define a prompt, a logic branch, a pipeline in Linkly, you’re not writing a script — you’re compiling intent into a form the LLM can execute reliably, with the kind of optimization passes that make real systems fast.

Is it finished? No. Is it proven at scale? No. Will it make traditional languages obsolete overnight? Of course not. But the first C compilers were terrible too. The first JavaScript engines were a joke. Every paradigm shift starts rough, and the people who wait for polish are always the ones explaining why they missed it.

The question isn’t whether Linkly succeeds. The question is whether you recognize the shift before it’s obvious.

If you’re building AI systems and still writing raw Python prompt strings with no compilation layer between your intent and the model, you’re doing it the hard way. You’re hand-cranking an engine that deserves a transmission. Linkly — or something like it — is coming for your stack. The only real question is whether you’ll be early or late.