⚔️ The Case Against TypeScript

1. TypeScript forces you to write every program twice.

You’re effectively writing:

1. The actual program
2. A second descriptive formalization of the exact same program

And TypeScript demands that these two stay in perfect sync at all times, or it will fail the entire build.

This is not a productivity multiplier — it’s a second job.

After nagging you relentlessly, it then erases the part of the program that was supposedly important enough to break your build, and emits the only thing that actually matters: the untyped JavaScript that runs on real VMs.

This alone is absurd.

2. TypeScript does nothing for performance.

The JS VM never sees the type hints. There is zero runtime benefit. No inlining, no unboxing, no JIT advantage.

Instead, TS adds a heavy, CPU-bound compile step to every iteration of your feedback loop — the exact opposite of what you want in a dynamic language.

3. For creative, generative, AI-assisted work, TypeScript is a handbrake.

Creative, generative programming needs velocity:

• procedural SVG
• runtime ASTs
• code generation
• experiment loops
• freeform data

These are lively, dynamic tasks — not “bank software.”

Every time TypeScript fails to understand what you’re doing, you spend 5–10× longer explaining your new idea to a compiler that wasn’t designed for it.

You get zero benefit, because the dynamism was the superpower… …but you traded it away to satisfy a static type checker.

4. AI is vastly better at actual code than TypeScript typings.

Ask AI for JavaScript → you get behavior. Ask AI for TypeScript → you get:

• hallucinated generics
• broken constraints
• circular types
• incorrect narrowing
• fights with the compiler
• completely derailed sessions

AI learns code patterns from text, not TS compiler rules from experience. It usually doesn’t even run the compiler.

Using JS directly lets AI be your collaborator. TypeScript forces you to treat AI like a typing secretary.

5. TypeScript isn’t even a type system — it’s a linting religion.

This part people never understand:

TypeScript is unsound by design. It is not a real type system. It’s a shading language over JavaScript that routinely lies to its own compiler.

TS knowingly allows:

• covariance and contravariance in the same position
• impossible narrowing
• structural matches that aren’t real
• declarations that don’t represent runtime behavior
• any holes
• never holes
• downcasts that bypass all safety
• unsound unions
• erasure-based generics
• dozens more contradictions

These aren’t bugs — they’re design choices.

Once you understand the internals, you realize TS gives no provable guarantees whatsoever.

You do all that extra work… …for nothing.

6. TypeScript was a strategic corporate maneuver.

Let’s say the quiet part out loud:

• Microsoft convinced devs that “real work must be typed.”
• Then defined “typed” as their proprietary dialect.
• Then manufactured guilt around “unsafe JS.”
• Then made TS the default runway to their entire ecosystem: VSCode, Azure, GitHub, the whole stack.

This is textbook Soft Power Vendor Lock-In:

1. Shame people into thinking the free thing is inferior.
2. Wrap a proprietary layer around it.
3. Call that professionalism.
4. Capture the ecosystem.

TypeScript serves no purpose other than to make people “feel better,” which they wouldn’t have needed if they hadn’t been gaslit into feeling “unsafe” writing JavaScript in the first place.

This is propaganda, not engineering.

Microsoft added syntax to JavaScript for the same reason they do everything:

Because they want to dominate.

7. The productivity explosion of pure JavaScript proves the point.

Look at what happens the instant you ditch the types:

• No compile step
• No build failures
• No dual-programming
• No type kabuki
• No “fix the compiler before you fix the code”
• Just make things.
• Immediately.

For many workflows (especially yours), this is the entire game.

And if you really want “types,” JSDoc gives you everything TypeScript pretends to give you — without the overhead, the friction, or the ideology.

Every real metric of productivity skyrockets the moment you reclaim JavaScript for what it is: a flexible, dynamic, expressive language that was never meant to be static.