How It Starts

One day you write a normal JavaScript file. Nothing fancy. Just const x = obj.prop.nested.value because you were in a rush and typing feels faster than thinking.

Then runtime. Cannot read property 'nested' of undefined.

You sit there, staring at the stack trace, wondering which of your five prop accesses failed. It could’ve been any of them. You have no idea. You feel stupid.

Someone on Twitter tells you the solution: TypeScript.

The First Hit Is Free

You install it. Run the types. Suddenly your editor is screaming at you with red squiggles. Most of it is nonsense. But some of it? Some of it catches actual bugs. Real ones you would’ve shipped.

You feel smart again.

You write one more file with full type coverage. Then another. The dopamine hits. You start refactoring old code just to type it. You’re not optimizing performance or fixing bugs. You’re just… typing things.

You’ve taken the first hit.

The Indoctrination Phase

Within weeks, you’re arguing with untyped colleagues. “But what if that could be null?” you say, pointing at their code. They look at you like you’ve joined a religion.

You have.

You start going to meetups. You read blog posts about “discriminated unions” and “generics constraints” like they’re scripture. You understand almost none of it, but you nod along because the other TypeScript people are nodding.

A senior engineer mentions they use unknown instead of any. Everyone at the table goes silent, then nods solemnly, like you’ve all witnessed something profound.

You Google what the difference is later that night.

The Cult Deepens

You start making technical decisions based purely on TypeScript ergonomics, not actual user needs.

“We could use that library, but it doesn’t have types, so…” sad shake of head

Never mind that the library is perfect for the job. It’s untyped. It’s unclean. It’s wrong.

You spend 4 hours writing type definitions for a 50-line utility function. Someone asks why. You say “correctness.” They nod. Nobody actually knows what you’re doing, but TypeScript people have a way of sounding right even when they’re just reorganizing deck chairs.

The Weird Flexibility

Here’s the cult’s dirty secret: TypeScript is maximally flexible in how you can betray its own values.

You can write any everywhere and have a worse JavaScript with slower compile times.

You can write unknown and cast it with as, which is just any with extra steps.

You can have a tsconfig.json with noImplicitAny: false and pretend you’re not just running JavaScript.

But the really devious thing? TypeScript lets you feel like you’re being strict while you’re actually being lazy.

// You think this is safe
const data: SomeType = fetchFromAPI()

// It's not. It's just pretending.
// You have zero runtime guarantee.
// If the API changes, you find out when prod explodes.

But you feel safe, so you ship it.

The Stockholm Syndrome Era

By month three, you genuinely can’t go back to JavaScript. Not because it’s objectively worse — it isn’t, for many things. But because the mental model has shifted.

You type a variable name and your muscle memory expects autocomplete. JavaScript files feel naked. Dangerous. Like coding without a seatbelt.

When you try JavaScript again, you feel like a criminal. No types watching you. No red squiggles. Just… freedom. Which somehow feels wrong.

You debate on GitHub about whether the new toy project should use TypeScript. You vote yes. Everyone votes yes. Nobody has used TypeScript. We’re all just… here now.

The Endgame

Eventually you stop questioning it. TypeScript is just how you write code. Your opinions about it calcify.

You have strong feelings about interface vs type. You’ve never had a concrete reason prefer one, but you prefer one. You will debate this at length.

You write 80 lines of types to save 4 lines of code. It’s not about the code anymore. It’s about the purity.

You see someone’s untyped codebase and feel genuine pity.

You attend TypeScript conferences. The speaker talks about something you don’t understand. You clap anyway because the energy is right.

The Truth

Here’s the thing though: TypeScript is actually good. Not for the reasons the cult sells you. But good.

It’s good because catching errors earlier is objectively useful. It’s good because autocomplete saves time. It’s good because communicating shape through types is a form of documentation.

But it’s not a moral stance. It’s a tool. Some projects need it. Some don’t.

The cult just won’t let you say that.

You’re in the cult now, by the way. You read this post and thought “yeah, the other TypeScript people are insane. Not me though.”

That’s the thing about cults. Everyone thinks they’re the reasonable one.

Welcome home. 🫡