You’ve probably had that moment. 3 AM, a half-empty coffee cup, and the sudden, crystal-clear vision of the perfect project. The one that will change everything. You can almost feel the keystrokes, taste the victory. Then morning comes, and reality hits: you have no money, no computer, and the entire premise might be obsolete anyway.
That’s the exact story behind a recent Hacker News post that’s both heartbreaking and brilliantly honest. A developer—let’s call him the Dreamer—announced his plan to build a ‘true TypeScript compiler’ by modifying Go’s parser to understand TypeScript, adding goroutines, and even slice syntax for AI. The kicker? He asked for a loaner laptop and a Codex subscription.
This isn’t a joke. It’s a raw, unfiltered glimpse into the soul of a programmer who loves TypeScript so much he’s willing to build a new runtime from scratch—while admitting he doesn’t have the hardware to start.
But the most jaw-dropping part? He undercuts his own revolutionary idea: ‘Honestly, now that AI codes everything, I’m not really sure that the programming language matters that much.’
Let that sink in. The man who wants to build the next great compiler just told us the whole game might be pointless. That’s not a contradiction—it’s the most honest thing you’ll read all week.
Here’s what the Dreamer got right: TypeScript is beautiful. Its expressiveness, its type system, its ability to let you think in code. But he’s dead wrong about the hard problem. The bottleneck isn’t the parser—it’s the runtime. Go’s goroutines are a runtime feature, not a parser trick. You can’t just swap out Go’s parser for TypeScript’s syntax and suddenly get concurrent execution. You’d need to reimplement the entire Go scheduler, the garbage collector, the memory model—the stuff that made Go great in the first place.
Think of it this way: Swapping a parser is like changing the shape of a keyhole. The real lock is the entire runtime engine behind the door.
The top comment on the post nails it: ‘Static languages allow significantly more complex systems simply because types are a form of documentation and they allow one to refactor.’ That’s the real value of TypeScript—not its runtime performance, but its ability to make large codebases manageable. The Dreamer is trying to solve a problem that doesn’t exist, while ignoring the one that does.
And then there’s the AI bombshell. If AI writes most of our code, what’s the competitive advantage of a language? It’s not syntax. It’s not runtime speed. It’s the ability to express complex invariants that an AI can’t hallucinate. Strong types, human reasoning, and the ability to refactor safely—that’s what matters. The Dreamer’s project would be a fun intellectual exercise, but it’s a distraction from the real shift.
Here’s the uncomfortable truth: The future of programming isn’t about building faster compilers. It’s about building tools that let humans reason about what the AI generates.
So what can we learn from the Dreamer? First, that passion without hardware is just a dream. But more importantly, that the most valuable thing in programming isn’t the language—it’s the clarity of thought it enables. TypeScript’s types are that clarity. Go’s goroutines are a different kind of clarity. Trying to mash them together without understanding the runtime is like trying to build a car by bolting an airplane wing onto a bicycle.
The Dreamer deserves respect for the audacity. But the rest of us should focus on what actually makes code maintainable, scalable, and safe. Whether AI eats the world or not, strong types will remain the last refuge of human intelligence in a sea of generated code.
Stop dreaming about the perfect compiler. Start building the code that the next AI will struggle to understand.
FAQ
Q: Isn't the Dreamer's idea technically feasible? Couldn't you modify Go's parser to parse TypeScript?
A: Technically, you could modify the parser, but that's the easy part. The hard part is the runtime: goroutines, garbage collection, memory model. You'd essentially need to build a new runtime from scratch, not just repurpose Go's parser. It's like saying you'll build a car by attaching a boat engine to a skateboard—possible, but not practical.
Q: What's the practical takeaway for developers who read this?
A: Stop obsessing over language syntax and runtime features. Focus on what makes your code understandable and maintainable: strong type systems, clear documentation, and the ability to refactor safely. In an AI-driven future, these human reasoning tools will be your only competitive advantage.
Q: Does AI really make programming languages irrelevant?
A: No, but it shifts the value. The language itself matters less because AI can generate code in any syntax. What matters is the human ability to specify intent, verify correctness, and reason about complex systems. TypeScript's type system is a tool for that reasoning—not a runtime feature. The Dreamer's project misses that point entirely.