TypeScript 5.8 was released in February 2025 (referring to the version adopted in actual projects here). After several months of production use, here are some real-world experiences with TypeScript's strict type system—which new features are genuinely useful, and which ones cause unexpected headaches in large projects.

TypeScript 5.8 Key Features Overview

1. --erasableSyntaxOnly: Optimized for Native Node.js TS Support

Node.js 22+ supports running .ts files directly (without generating .js), but only supports "erasable syntax" (no runtime syntax like enum or namespace). TS 5.8 adds the --erasableSyntaxOnly flag to detect violations:

// tsconfig.json (for Node.js native TS projects)
{
  "compilerOptions": {
    "erasableSyntaxOnly": true // Disallows enum, namespace, and other runtime syntax
  }
}

// ❌ Error: enum is not erasable syntax
enum Status {
  Active,
  Inactive,
}

// ✅ Alternative: const object + type
const Status = {
  Active: "active",
  Inactive: "inactive",
} as const;
type Status = (typeof Status)[keyof typeof Status];

// ✅ Alternative: string literal union
type Status = "active" | "inactive";

2. Improved infer in Conditional Types

// Before TS 5.8: extracting the inner type of a Promise's return required nested infer
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type UnwrapAll<T> =
  T extends Promise<infer U>
    ? UnwrapAll<U> // manual recursion required
    : T;

// TS 5.8: infer extends syntax is more powerful
type ExtractArrayItem<T> = T extends (infer Item)[]
  ? Item extends string
    ? `string:${Item}`
    : Item
  : never;

// More practical: extract the exact shape of an API return type
type ApiResponse<T extends (...args: any) => any> =
  Awaited<ReturnType<T>> extends { data: infer D } ? D : never;

// Usage example
async function fetchUser(id: string): Promise<{ data: User; meta: Meta }> {
  return await api.get(id);
}
type UserData = ApiResponse<typeof fetchUser>; // User

TypeScript Strict Type Issues Encountered in Production

Issue 1: noUncheckedIndexedAccess and Array Operations

// tsconfig.json
{
  "compilerOptions": {
    "noUncheckedIndexedAccess": true  // Once enabled: array access returns T | undefined
  }
}

// ❌ After enabling, previously valid code now errors
function getFirst<T>(arr: T[]): T {
  return arr[0];  // Error: Type 'T | undefined' is not assignable to type 'T'
}

// ✅ Fix 1: non-null assertion
function getFirst<T>(arr: T[]): T {
  return arr[0]!;  // (ensure the array is non-empty)
}

// ✅ Fix 2: safer signature
function getFirst<T>(arr: [T, ...T[]]): T {  // tuple with at least one element
  return arr[0];
}

// ✅ Fix 3: handle undefined explicitly
function getFirst<T>(arr: T[]): T | undefined {
  return arr[0];
}

Practical advice: Enabling noUncheckedIndexedAccess in large projects produces a large number of errors to fix. It is recommended to try it in new modules first rather than enabling it project-wide.

Issue 2: Performance Overhead of the satisfies Operator

// satisfies has a noticeable type-checking performance cost on complex objects,
// especially for large config objects

// ❌ Heavy use of satisfies on large objects slows down tsc
const config = {
  routes: [...],  // 1000+ route configs
  plugins: [...], // 100+ plugins
} satisfies AppConfig;

// ✅ In performance-sensitive scenarios, use a type annotation instead
const config: AppConfig = {
  routes: [...],
  plugins: [...],
};

Issue 3: Recursion Limits with Template Literal Types

// Deeply nested template literal types can trigger TypeScript's recursion limit
type DeepPath<T, Prefix extends string = ""> = T extends object
  ? {
      [K in keyof T]: T[K] extends object
        ? `${Prefix}${K & string}` | DeepPath<T[K], `${Prefix}${K & string}.`>
        : `${Prefix}${K & string}`;
    }[keyof T]
  : never;

// For objects deeper than 4–5 levels, TypeScript reports "Type instantiation is excessively deep"
// Practical tip: limit depth or use runtime validation (zod, yup) instead of complex type inference

Valuable New Capabilities in TS 5.8

// 1. Smarter control flow narrowing (automatic narrowing is now more precise than ever)
function processValue(val: string | number | null) {
  if (val === null) return;
  // 5.8: val's type is inferred more accurately across complex branches
  const result = typeof val === "string" ? val.toUpperCase() : val.toFixed(2);
  // result: string (5.8 correctly infers the result type across union branches)
}

// 2. Decorator metadata improvements (works with Angular/NestJS)
// TS 5.8 better supports metadata access for Stage 3 decorators

Summary

TypeScript 5.8 continues the 5.x series' rhythm of "steadily polishing edge cases" without any breaking changes. The most valuable additions for production projects are --erasableSyntaxOnly (preparing for native Node.js TS) and improved control flow narrowing. noUncheckedIndexedAccess is theoretically safer but has a high adoption cost in large projects—introduce it gradually in new modules rather than all at once.