When should I use an interface versus a type?

According to these best practices, interfaces should be reserved for defining behavior contracts (like dependency injection), while types should be used for data structures and definitions.

Why does this skill prefer 'unknown' over 'any'?

The 'any' type disables type checking entirely, while 'unknown' forces the developer to perform type narrowing or assertions, maintaining strict type safety throughout the application.

How does the skill handle function parameters?

It enforces the 'options object' pattern for functions with 3 or more parameters to improve readability and prevent errors associated with positional arguments, especially booleans.

What is schema-first development in this context?

It is a pattern where you define validation schemas first and derive your TypeScript types from those schemas (e.g., using z.infer), ensuring that data entering your app at runtime matches your compile-time types.

TypeScript Best Practices

Name: TypeScript Best Practices
Author: mintuz

bymintuz

•

Developer Tools

Outputs strict, schema-first, and production-ready TypeScript code emphasizing type safety and immutability.

About

This skill optimizes Claude for high-quality TypeScript development by enforcing a schema-first approach where types are derived from validation schemas. It prioritizes runtime safety at trust boundaries, strict immutability, and explicit type definitions to eliminate technical debt and runtime errors. Whether building web APIs, mobile apps, or complex frontend systems, it provides a comprehensive framework for writing clean, maintainable code using modern patterns like branded types, options objects, and result-based error handling.

Key Features

Strict immutability enforcement using readonly modifiers and spread patterns
14 GitHub stars
Elimination of 'any' types in favor of 'unknown' and explicit contracts
Schema-first development for guaranteed runtime-to-compile-time type safety
Identification and validation of trust boundaries (APIs, user inputs, files)
Standardized patterns for error handling using Result types and early returns

Use Cases

Architecting type-safe API layers with automated schema validation
Refactoring legacy JavaScript or loose TypeScript into strict, production-grade codebases
Implementing complex domain logic using branded types to prevent primitive obsession

About

Key Features

Strict immutability enforcement using readonly modifiers and spread patterns
14 GitHub stars
Elimination of 'any' types in favor of 'unknown' and explicit contracts
Schema-first development for guaranteed runtime-to-compile-time type safety
Identification and validation of trust boundaries (APIs, user inputs, files)
Standardized patterns for error handling using Result types and early returns

Use Cases

Architecting type-safe API layers with automated schema validation
Refactoring legacy JavaScript or loose TypeScript into strict, production-grade codebases
Implementing complex domain logic using branded types to prevent primitive obsession