TypeScript Strict

Treat the type system as the primary correctness tool. Tests verify behaviour; types prevent entire categories of bug from existing.

Hard rules

1. tsconfig.json must have "strict": true and "noUncheckedIndexedAccess": true. Don't merge without these.
2. No any in application code. unknown for external input, then narrow. Generics where the type depends on the caller.
3. No type assertions (as Foo) unless paired with a runtime check that proves the assertion. Prefer satisfies.
4. No enum unless required for interop with a non-TS consumer. Use string-literal unions: type Role = 'admin' | 'member'.
5. No React.FC for components — use a typed props parameter. FC makes children implicit which causes confusion.

Patterns

Parse, don't validate

Convert untrusted data to a typed value at the system boundary, then trust the type everywhere downstream:

import { z } from "zod";

const UserSchema = z.object({
  email: z.string().email(),
  age: z.number().int().min(0).max(150),
});
type User = z.infer<typeof UserSchema>;

export function parseUser(raw: unknown): User {
  return UserSchema.parse(raw); // throws on invalid
}

Once you have a User, no other code needs to validate it again.

Exhaustive switches

Use a never exhaustiveness check on discriminated unions so adding a new variant fails the build:

type Event =
  | { kind: "created"; id: string }
  | { kind: "updated"; id: string; patch: Partial<User> }
  | { kind: "deleted"; id: string };

function describe(e: Event): string {
  switch (e.kind) {
    case "created": return `created ${e.id}`;
    case "updated": return `updated ${e.id}`;
    case "deleted": return `deleted ${e.id}`;
    default: {
      const _exhaustive: never = e;
      throw new Error(`unhandled event ${JSON.stringify(_exhaustive)}`);
    }
  }
}

Branded types for IDs

Use brands so you can't accidentally pass a UserId where an OrderId is expected:

type Brand<T, B> = T & { readonly __brand: B };
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;

function userId(s: string): UserId { return s as UserId; }
function orderId(s: string): OrderId { return s as OrderId; }

Immutable updates

Mutation is forbidden. Always return new values:

// WRONG
function rename(user: User, name: string): User {
  user.name = name; // mutation!
  return user;
}

// RIGHT
function rename(user: Readonly<User>, name: string): User {
  return { ...user, name };
}

Errors as values for expected failures

Throwing is for bugs and unrecoverable states. For expected failures (validation, not-found, network), return a discriminated result:

type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };

What to flag in review

• any anywhere except in // @ts-expect-error: <reason> comments.
• as casts without a runtime guard.
• Throwing inside a function whose signature claims it always returns.
• Using .then instead of await (mixed styles in one function).
• A Map or Set typed with <any, any>.
• A discriminated-union switch without a never default.