I love Rust. I’d mass-adopt Odin tomorrow if I could. For years I did exactly that — picked the best tool for the job, explored languages that let me squeeze every cycle out of a problem. It was fun. It was educational. And eventually, it bit me in the ass.
The fantasy
You find a problem. You think: “This deserves a proper solution.” So you reach for Rust. Or you prototype something in Odin because the memory model is elegant and you want to see how far you can push it. The code is fast. The binary is small. You feel like an engineer.
This works beautifully when you are the only person who will ever touch it.
The reality
You ship the CLI tool in Rust. You write the build pipeline helper in Odin. Your internal scraper is a Go binary. Your frontend is SvelteKit. Your glue scripts are a mix of Bash and Python.
Now you have five ecosystems. Five sets of dependencies. Five build systems. Five mental contexts to load when something breaks at 2 AM.
And it will break at 2 AM.
Where it actually hurts
The real cost is not the code. The code works. The real cost shows up in two places:
You become the single point of failure
Every exotic choice is a decision only you can maintain. You wrote it, you debug it, you deploy it, you explain it. There is no “let me hand this off” because handing it off means teaching someone an entire language ecosystem first.
The first new team member
This is where the fantasy dies. You get your first hire. Or a collaborator joins the project. They are smart. They can code. But they have never touched Rust’s borrow checker. They have never heard of Odin. They stare at your elegant solution and they cannot contribute.
You wrote it in TypeScript? They open the file, read it, push a fix. Done. No onboarding. No “let me walk you through the toolchain.” They are productive on day one.
The genius is not in the extravagance
I used to think good engineering meant picking the optimal tool for every problem. The fastest runtime. The most expressive type system. The most elegant abstraction.
It doesn’t. Good engineering means your system survives contact with reality. Reality is:
- You will not maintain this alone forever
- The next person will not share your exact taste in languages
- Context-switching across five ecosystems has a compounding cost
- The “boring” choice scales to teams, the “clever” choice scales to you
What changed
I still write Rust when it genuinely matters — performance-critical paths, systems-level work where the tradeoff is justified. I still explore Odin for fun and learning.
But scripts? Tools? Internal pipelines? Automation? CLIs that someone else might touch someday?
TypeScript. Every time.
Not because it’s the best language. Because it’s the language that disappears. Everyone on the team already knows it. The ecosystem is enormous. The tooling is mature. The onboarding cost is zero.
The uncomfortable truth
The uncomfortable truth is that the most valuable engineering decision is often the most boring one. You are not optimizing for elegance. You are optimizing for bus factor.
Write it in the language your team can read. Write it in the language your future self won’t curse. Write it in the language that lets other people help you.
That language, for me, is TypeScript.