typescript-strict

Use when writing TypeScript with strict mode - covers type definitions, generics, and declaration files

⭐3stars🔀0forks📁View on GitHub🕐Updated Jan 1, 2026

When & Why to Use This Skill

This Claude skill provides a comprehensive framework for writing high-quality TypeScript in strict mode. It focuses on enhancing type safety and code robustness by implementing best practices for type definitions, advanced generics, and declaration files. By leveraging patterns like discriminated unions and strict null checks, it helps developers minimize runtime errors and maintain a clean, scalable codebase.

Use Cases

  • Configuring tsconfig.json with strict flags to establish a high-standard development environment.
  • Implementing complex data structures using discriminated unions and type guards for exhaustive type checking.
  • Developing reusable and type-safe utility functions using constrained generics and conditional types.
  • Authoring accurate declaration files (.d.ts) for external modules to improve IDE intellisense and type coverage.
  • Refactoring legacy TypeScript code to eliminate implicit 'any' types and handle null/undefined values explicitly.
nametypescript-strict
descriptionUse when writing TypeScript with strict mode - covers type definitions, generics, and declaration files

TypeScript Strict Mode Best Practices

Quick Start

// Enable strict in tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true
  }
}

Core Principles

  • Strict null checks: Handle undefined and null explicitly
  • No implicit any: Always declare types, avoid any
  • Readonly by default: Use readonly for immutable data
  • Discriminated unions: Use type guards with tagged unions

Type Definition Patterns

AST Node Types

// Discriminated union for AST nodes
type Expr =
  | { type: "NumberLiteral"; value: number }
  | { type: "BinaryExpr"; op: string; left: Expr; right: Expr }
  | { type: "Identifier"; name: string };

// Type guard
function isNumberLiteral(expr: Expr): expr is Extract<Expr, { type: "NumberLiteral" }> {
  return expr.type === "NumberLiteral";
}

Generic Types

// Constrained generics
function map<T, U>(arr: readonly T[], fn: (item: T, index: number) => U): U[] {
  return arr.map(fn);
}

// Conditional types
type Unwrap<T> = T extends Promise<infer U> ? U : T;

Declaration Files

// module.d.ts
declare module "lea-lang" {
  export function run(code: string): unknown;
  export function parse(code: string): Program;
}

Common Patterns

  • Use unknown over any for safer type narrowing
  • Prefer interface for extendable types, type for unions
  • Use as const for literal types
  • Leverage satisfies for type checking without widening

Reference Files