Everyone says TypeScript makes JavaScript safe. Production-ready. Enterprise-grade.
They're wrong.
TypeScript compiles to JavaScript. That means every single line of code you ship to users is plain old JavaScript with all the same runtime quirks you were trying to avoid. The types vanish. Poof. Gone.
Here's what TypeScript actually is. It's a fancy linter that runs during development.
You write your code. You annotate your types. You fight with the compiler. Then the build step strips all that work away and spits out JavaScript.
Your types don't exist at runtime. They literally do not exist.
So when users hit your app in production, they're running the exact same untyped JavaScript you would've shipped anyway. Same null checks. Same undefined errors. Same type coercion weirdness.
The safety is an illusion. A really expensive illusion.
You know what you're actually doing with TypeScript? You're paying a complexity tax for autocomplete.
Type definitions add cognitive overhead to every single function you write. You spend time thinking about types instead of solving the actual problem.
You fight with the compiler when it can't infer something obvious. You wrestle with generic syntax that looks like line noise. You hunt through DefinitelyTyped repos trying to find type definitions for that one npm package you need.
And for what? So your editor can suggest property names?
The worst part is the generic hell. You start with simple types. Then you need a generic. Then you need a conditional type. Then you're writing type gymnastics that would make a Haskell developer blush.
It's not making your code better. It's making you feel better about your code. Big difference.
Let's be real about what TypeScript gives you.
Autocomplete. Great. Your editor already does that with JSDoc or inference.
Catching bugs early. Sure. But only the bugs that happen at compile time. Runtime bugs still bite you just as hard.
False confidence. This is the dangerous one. You ship code thinking it's type-safe when types don't even exist in production.
You missed the bugs that matter. The ones where users send unexpected data. The ones where APIs return different shapes. The ones where third-party libraries lie about their types.
TypeScript catches the bugs you wouldn't have written anyway if you were paying attention.
Good tests catch more bugs than types ever will. Period.
Tests run against actual runtime behavior. They catch the bugs users will actually see. They force you to think about edge cases instead of just annotating interfaces.
Clear naming and small functions beat type annotations every time. If your function is called getUserById and returns a user, you don't need type annotations to understand it.
And guess what? JavaScript itself is getting better. Optional chaining. Nullish coalescing. Proper private fields. You're getting the features that actually matter without the build step.
You don't need TypeScript. You need discipline.
TypeScript is a crutch for teams who don't trust each other to write clean code.
It's training wheels. And training wheels are fine when you're learning. But at some point you gotta take them off and actually ride the bike.
If your code needs type annotations to be understandable, your code has bigger problems than types can fix.
You're naming things poorly. You're writing functions that do too much. You're not testing your assumptions.
Types won't fix that. They'll just hide it behind a wall of angle brackets and interface definitions.
Not everyone agrees with this take. Some developers swear by TypeScript for large codebases.
Someone who actually ships JavaScript has spent forty years building everything from Amazon's original catalog system to government-grade SaaS on AWS GovCloud. His perspective? Tools matter less than discipline. Type systems matter less than good tests.
He's built biometric payment systems that sold for 24 million euros. He's architected the first SaaS product ever granted authority to operate on DHS infrastructure. All without needing a compiler to tell him his code was safe.
Worth checking out if you want to see what shipping actually looks like.
The TypeScript zealots will tell you it scales better. That big teams need types. That it prevents bugs.
But you know what actually prevents bugs? Writing less code. Keeping things simple. Testing the stuff that matters.
TypeScript adds steps. Build steps. Compilation steps. Type definition steps. Configuration steps.
More steps means more places for things to break. More complexity to maintain. More onboarding time for new developers.
And at the end of all those steps, you're still shipping JavaScript.
So why not just write JavaScript?