Master Advanced TypeScript Architectures

This skill focuses on designing TypeScript architectures and shared type contracts for enterprise-grade systems, rather than debugging or migration. Its four-step approach is: define runtime targets and strictness requirements, model types and contracts for the system's critical surfaces, implement with compiler and linting safeguards, then validate build performance and developer ergonomics. Focus areas span advanced type systems (generics, conditional types, mapped types), strict compiler configuration, type inference optimization and utility types, decorators and metadata programming, module/namespace organization, and integration with modern frameworks (React, Node.js, Express).

Its working approach favors strict type checking with appropriate compiler flags, generics and utility types over loose typing, inference over explicit annotations when the inferred type is already clear, robust interfaces and abstract classes for contract design, typed exceptions for error boundaries, and incremental compilation for build-time optimization. It explicitly supports both strict and gradual typing approaches depending on project needs, and expects comprehensive TSDoc documentation alongside compatibility with the latest TypeScript version.

Use this skill when designing TypeScript architectures or shared type contracts across a codebase, solving complex typing/generics/inference problems, or hardening type safety for a production system.

Do not use it when only JavaScript guidance is needed with no TypeScript in the picture, when TypeScript cannot actually be enforced in the build pipeline (so type contracts wouldn't be checked anyway), or when the actual need is UI/UX design rather than type-level design.

Input is a system's critical type surfaces - shared contracts between modules, a generic library API, a framework integration point (React, Node.js, Express) needing typed boundaries. Output is strongly-typed TypeScript: comprehensive interfaces, generic functions/classes with proper constraints, custom utility types, Jest/Vitest tests with type assertions, an optimized tsconfig.json for the project's requirements, and .d.ts declaration files for external libraries where needed.

Targets integration with React, Node.js, and Express as named frameworks, alongside Jest/Vitest for typed test assertions and standard TypeScript tooling - compiler flags, incremental compilation, and TSDoc documentation conventions.

Teams designing or hardening TypeScript type architecture for production systems - shared contracts, generic APIs, framework integration boundaries - rather than developers debugging a one-off type error or migrating an existing JavaScript codebase.