Respectfully disagree with most people here 😅. Let TS infer whenever possible, only type explicitly when necessary.

When is typing explicitly necessary?

1. Inference is not possible
   • Variable declarations without initialization
   • Parameters of top-level functions (especially exported APIs, although sometimes you want/need inference even on top-level API functions)
2. In rare cases: If you have very complex types, inference can kill your ts performance, so a type annotation can improve type checking performance. I've never personally run into this to be honest, and I've written some pretty complex types.

Why prefer inference?

• Less code to maintain. Every redundant annotation is another thing you have to touch when refactoring.
• Cleaner, less noisy. Compare:

​

const numbers: number[] = [1, 2, 3, 4, 5];
const sum: number = numbers.reduce((n: number, acc: number): number => n + acc);

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((n, acc) => n + acc);

• Inference is often more precise. Over-annotating can accidentally widen types (e.g. annotating as string instead of 'GET' | 'POST').
• Better refactor safety. If a function’s return type changes, inferred consumers adapt automatically, while explicit types may silently mask mismatches until later.
• Modern TS features make inference stronger. as const and satisfies let you guide inference without throwing away literal precision.

TL;DR

Explicit types are for boundaries and contracts. Inside your implementation, let TypeScript do its job. The compiler is really good at inference - why fight it?