The Power of Generics in TypeScript

👉 Watch on YouTube

Some time ago, I realized something uncomfortable in my code: I was using any more than I should.

And yeah… it works. But it’s also a trap.

Because every time you use any, you’re telling TypeScript: “trust me… I know what I’m doing” when in reality you’re giving up all the safety the language provides.

In this video, I wanted to show something practical: why generics are not an advanced topic, but a tool we should be using from day one.

The problem with any

Let’s be honest. any isn’t the problem. The problem is how we use it.

We use it because:

• we want to move fast
• we don’t want to think about the type
• or simply… “it already works”

But that shortcut comes at a cost.

You lose:

• autocomplete
• compile-time validation
• intent in your code

And that’s where silent bugs start creeping in.

The mindset shift

The real shift is this:

Stop using any when what you actually need is flexibility with control.

That’s where generics come in.

This is where everything changes

When I started using generics properly… my code changed.

Because now I can:

• keep autocomplete
• preserve type safety
• reuse logic without breaking types
• and clearly express what goes in and what comes out

I no longer write rigid functions.

I write functions that adapt… without losing information.

This is not abstraction for the sake of abstraction

There’s something important here.

Generics are not about making code more “complex”.

They’re about making it more honest.

Especially when:

• code is shared
• helpers are reused
• or the project starts to grow

If a function works with multiple types… a generic lets you say that clearly.

No hacks.
No any.
No lies.

The takeaway

This isn’t magic.

It’s design.

Generics force you to think in terms of contracts.

And that makes your code:

• safer
• more reusable
• more maintainable

If you’re still using any as a quick fix… we need to talk.

Because you’re not solving the problem.

You’re hiding it.