writing-typescript

Strict typing in TypeScript eliminates the any type by using unknown, type guards, and discriminated unions to enforce compile-time safety. This Skill provides patterns and tsconfig configurations to enforce no-any rules across Node.js services, React applications, and general codebases, ensuring type safety at every layer.

Type guards narrow union types safely through runtime checks, while discriminated unions use a shared literal property to distinguish between union members. These patterns replace unsafe type casting and enable robust handling of complex data structures in async operations, API responses, and application logic.

Project scaffolding with standard tooling configurations establishes consistent code organization, linting, formatting, and bundling across your codebase. This Skill covers tsconfig setup, eslint and prettier integration, and build tool configuration for vite or bun to enforce idiomatic TypeScript patterns from project initialization.

Generic constraints enforce strict typing on reusable functions and classes by limiting type parameters to specific shapes. This Skill demonstrates how to use utility types and constrained generics to eliminate runtime type errors and improve code reusability across services and applications.

Safe async patterns in TypeScript include typed Promise handling, retry logic, and concurrent execution with proper error boundaries. This Skill provides composition-based patterns and type-safe wrappers for Node.js async operations, ensuring type correctness in concurrent and retry scenarios.

Composition over inheritance reduces coupling and improves type flexibility by combining smaller, focused types rather than building deep class hierarchies. This Skill enforces composition patterns to create maintainable, type-safe codebases that scale across tests, configuration, and feature development.