TypeScript Language Patterns

Enforce modern TypeScript coding standards for type safety and maintainability.

Updated Jan 22, 2026
One-click install
npx skills add https://github.com/ngxtm/skill-rule --skill typescript-language-patterns-ngxtm
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: TypeScript Language Patterns
Source: https://github.com/ngxtm/skill-rule/tree/main/rules/typescript/language
Command: npx skills add https://github.com/ngxtm/skill-rule --skill typescript-language-patterns-ngxtm

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill enforces modern TypeScript standards to ensure type safety, improve code maintainability, and boost performance.

Core Features & Use Cases

  • Type Safety: Enforces strict typing, null safety, and explicit annotations.
  • Maintainability: Promotes clear use of interfaces, types, and utility types.
  • Performance: Discourages anti-patterns like any and runtime enums.
  • Use Case: Ensure all new TypeScript features in a project adhere to best practices for robust and scalable applications.

Quick Start

Apply modern TypeScript standards to the current project's codebase.

Frequently Asked Questions about TypeScript Language Patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce strict type safety and avoid `any` in TypeScript?

To enforce strict type safety in TypeScript, apply coding standards that mandate explicit type annotations, enable strict mode in tsconfig.json, and discourage anti-patterns like the `any` type. This ensures robust, maintainable code.

What's the best way to configure TypeScript null safety and explicit annotations?

Configuring TypeScript null safety requires enabling strict mode and applying explicit type annotations across your codebase. Enforcing these modern standards ensures runtime safety and improves overall code maintainability.

Can I use this to enforce TypeScript best practices for interfaces and generics?

Yes, you can enforce TypeScript best practices for interfaces and generics by applying specific coding standards. This ensures clear usage of types, interfaces, and generics, promoting scalable application architecture.

Does this TypeScript standard apply to TSX files and tsconfig.json configurations?

Yes, these TypeScript standards apply directly to all TypeScript and TSX files, as well as tsconfig.json configurations. Applying these rules ensures consistent type safety and performance across the entire project.

Why should I avoid runtime enums in TypeScript for better performance?

You should avoid runtime enums in TypeScript because they introduce performance overhead and anti-patterns. Enforcing modern standards discourages their use, promoting better performance and improved code maintainability.

How do I maintain code quality when adding new TypeScript features?

To maintain code quality when adding new TypeScript features, apply modern coding standards for type safety, explicit annotations, and utility types. This ensures new features adhere to best practices for robust applications.