"Review this TypeScript" is the format that separates fluency from familiarity. The code compiles; the question is what will bite. This page lists the patterns that make a codebase pleasant and the smells that predict incidents, so you can name them quickly and explain the fix.

Know — patterns

• Discriminated unions for state and variants instead of optional fields and booleans; the kind property drives exhaustive switches and narrows in templates.
• Const objects instead of enums: const ROLE = { admin: 'admin', editor: 'editor' } as const; type Role = typeof ROLE[keyof typeof ROLE]; zero runtime, erasable, iterable (Object.values(ROLE)).
• Derive from values: keyof typeof, typeof x[number], ReturnType<typeof createStore>, z.infer; types written once, in one direction.
• Result and typed errors for expected failures; exceptions for the unexpected; never for exhaustiveness.
• Function-type utilities: Parameters, ReturnType, Awaited, NoInfer, satisfies for tables and configs, labelled tuples for emits and callbacks.
• Small, explicit public types: exported functions carry explicit return types (also required for isolatedDeclarations), internal helpers infer; interfaces for object shapes that may be extended, type aliases for unions and utilities.
• Branded primitives for ids, currency codes and validated strings; readonly on inputs you do not mutate (readonly T[]), which also documents intent.
• Type-level tests with expectTypeOf (Vitest) or // @ts-expect-error lines next to the code, so a typing regression fails CI.
• Lint the types: @typescript-eslint with strict-type-checked: no-explicit-any, no-unsafe-*, no-floating-promises, no-non-null-assertion, consistent-type-imports, switch-exhaustiveness-check.

Know — smells

• as casts on data you did not construct (as Product, as HTMLInputElement without checking, as any, as unknown as T): each one is a place where the type and the runtime can disagree silently. Replace with guards, schemas, or satisfies.
• Non-null assertions (!) sprinkled to silence strictNullChecks: a crash waiting for the one path where the value is null. Narrow explicitly or restructure so the value cannot be missing.
• any leakage: an any return from a helper (JSON.parse, an untyped SDK, a catch (e: any)) spreads into everything downstream. Wrap the seam in a typed function that returns unknown or a validated type.
• Boolean and optional soup: { loading?: boolean, error?: string, data?: T } allows eight combinations, four of them impossible. Discriminated union.
• Stringly-typed options: variant: string, event: string. Literal unions or template literal types.
• Over-generic helpers: a deepMerge<T, U, V, W> with conditional types nobody can read, or a component with <T, K extends keyof T, F extends (x: T[K]) => unknown> for one caller. Simplify or specialise.
• Type and runtime drift: an interface hand-written next to a schema, or props typed one way and validated another. Derive one from the other.
• Function, object, {} as types: Function accepts anything callable and disables call checking; {} means "any non-nullish". Use precise signatures, Record<string, unknown>, or unknown.
• Optional everywhere in DTOs because "the API might not send it": encode the real contract, and make the boundary validation enforce it.
• Slow types: enormous unions, deeply recursive conditional types, template literal permutations in app code; symptoms are a sluggish editor and a tsc that takes minutes. Diagnose with --extendedDiagnostics/--generateTrace, move complexity into libraries or replace with runtime code.
• @ts-ignore instead of @ts-expect-error: the former hides the error forever, the latter fails when the error disappears.

How it works

A review exercise: the same module before and after.

export async function loadUser(id: any) {
  const res: any = await $fetch('/api/users/' + id)
  const user = res.data as { name: string, email: string, role: string }
  if (user.role == 'admin' || user.role == 'editor') {
    localStorage.setItem('user', JSON.stringify(user))
  }
  return { loading: false, error: undefined, data: user, isAdmin: user.role === 'admin' }
}

export function greet(user: any) {
  return 'Hello ' + user!.name.toUpperCase()
}

import { z } from 'zod'

const ROLE = { admin: 'admin', editor: 'editor', viewer: 'viewer' } as const
type Role = typeof ROLE[keyof typeof ROLE]
const userSchema = z.object({ name: z.string(), email: z.string().email(), role: z.enum([ROLE.admin, ROLE.editor, ROLE.viewer]) })
type User = z.infer<typeof userSchema>
type UserId = string & { readonly __brand: 'UserId' }

type LoadState = { status: 'loading' } | { status: 'error', message: string } | { status: 'success', user: User }

export async function loadUser(id: UserId): Promise<LoadState> {
  try {
    const raw: unknown = await $fetch(`/api/users/${id}`) // template literal keeps the route type; `unknown` is honest for the demo
    const user = userSchema.parse(raw)                     // validated once, at the boundary
    if (canEdit(user.role)) persistUser(user)
    return { status: 'success', user }
  }
  catch (e) {
    return { status: 'error', message: e instanceof Error ? e.message : 'Unknown error' }
  }
}

const EDITOR_ROLES = new Set<Role>([ROLE.admin, ROLE.editor])
const canEdit = (role: Role) => EDITOR_ROLES.has(role)

export function greet(user: Pick<User, 'name'>): string {
  return `Hello ${user.name.toUpperCase()}`
}

Type-level tests that guard the contract:

import { expectTypeOf } from 'vitest'
import type { LoadState } from '~/utils/user'

expectTypeOf<Extract<LoadState, { status: 'success' }>['user']['role']>().toEqualTypeOf<'admin' | 'editor' | 'viewer'>()

// @ts-expect-error a plain string is not a UserId: the brand is enforced
loadUser('123')

Exercise

Be able to say