any, unknown, never: the top, the bottom, and the escape hatch

any — opt out of checking, and watch it spread

any is not “some type” — it’s “stop type-checking this value.” Anything is assignable to any, and any is assignable to anything. That second half is the dangerous one: it lets a value silently flow into positions that demand a specific type.

const data: any = JSON.parse('{"port": "oops"}');
const port: number = data.port; // ✅ no error — `any` -> number is allowed
//    ^? const port: number  — but at runtime it's the string "oops"

port.toFixed(2); // compiles; throws at runtime: toFixed is not a function

Worse, any is contagious. Read a property off an any, call it, index it — the result is any too, so the hole propagates through your whole call chain:

function getUser(): any { /* ... */ }

const u = getUser();      // any
const name = u.profile;   // any  — still no checking
const upper = name.bigify(); // any — `.bigify` doesn't exist, but no error

One any at the source quietly poisons everything downstream. This is why any should be rare, local, and intentional — never the type of a boundary like a parsed JSON body or an untyped library result.

unknown — the safe top type

unknown is the type-safe counterpart to any. Like any, it’s a top type: every value is assignable to it. Unlike any, you can do nothing with an unknown value until you narrow it to something more specific.

const data: unknown = JSON.parse('{"port": 8080}');

const port: number = data.port;
// Error: 'data' is of type 'unknown'.
//   Property 'port' does not exist on type 'unknown'.

if (typeof data === "object" && data !== null && "port" in data) {
  const p = data.port;
  //    ^? const p: unknown  — still unknown until further narrowed
}

unknown forces you to prove the shape before using it — with typeof, in, a type guard, or a runtime validator (Zod, Valibot). It’s the correct type for every untrusted boundary: JSON.parse, fetch().json(), localStorage, message-bus payloads. The detailed mechanics of narrowing are the next unit; here the point is simply which type to reach for: unknown, never any.

never — the empty bottom type

When would a value provably not exist? More often than you’d think — and when you use that fact intentionally, never becomes the most honest signal a function can return.

never is the type with no values — the empty set. It’s the bottom type: assignable to every type, but nothing (except never) is assignable to it. It shows up wherever a value provably cannot exist:

function fail(msg: string): never { // never returns normally
  throw new Error(msg);
}

function loop(): never { // never terminates
  while (true) {}
}

type Impossible = string & number;
//   ^? type Impossible = never  — no value is both string AND number

The most valuable use is exhaustiveness checking. After narrowing a union down to nothing, the remaining type is never — and you can assert it to force a compile error if a new case is ever added:

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "square": return s.side ** 2;
    default: {
      const _exhaustive: never = s; // s is narrowed to `never` here
      return _exhaustive;
    }
  }
}

Add { kind: "triangle"; base: number; height: number } to Shape and forget to handle it, and the default branch now sees s as that triangle type — not never — so const _exhaustive: never = s errors:

// Error: Type '{ kind: "triangle"; ... }' is not assignable to type 'never'.

A tiny assertNever helper makes this a one-liner you drop in every default:

function assertNever(x: never): never {
  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
}
// default: return assertNever(s);

This converts “I forgot a case” from a runtime surprise into a compile-time error — one of the highest-leverage patterns in the whole language.

The assignability lattice

Picture the types as a lattice. unknown sits at the top (everything fits into it), never at the bottom (it fits into everything), concrete types in the middle. any doesn’t really live in the lattice at all — it’s a sideways escape hatch that’s both a top and a bottom simultaneously, which is precisely what makes it unsound: