typescript-expert

Enforce strict TypeScript configurations and ESLint best practices during code review.

24|3|Updated Nov 25, 2025
One-click install
npx skills add https://github.com/nguyenthienthanh/aura-frog --skill typescript-expert
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: typescript-expert
Source: https://github.com/nguyenthienthanh/aura-frog/tree/main/aura-frog/skills/typescript-expert
Command: npx skills add https://github.com/nguyenthienthanh/aura-frog --skill typescript-expert

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Expert-level TypeScript patterns, strict type safety, and robust linting guidance for scalable JS/TS projects.

Core Features & Use Cases

  • Strict null handling and type guards
  • Discriminated unions and exhaustive checks
  • ESLint best practices for strict type-checked code
  • Practical TS examples with real-world patterns

Quick Start

Add strict TypeScript configuration and implement a type-safe function with guards.

Frequently Asked Questions about typescript-expert

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

FAQPage Schema
How do I enforce strict type safety in TypeScript projects?

Strict type safety in TypeScript is enforced through strict mode configuration and type guards that prevent null/undefined errors and catch type mismatches at compile time. Enable `strict: true` in tsconfig.json, implement discriminated unions for exhaustive type checking, and use type guard patterns to safely narrow types before runtime operations.

What's the best way to configure ESLint for TypeScript code quality?

Configure ESLint for TypeScript by pairing it with typescript-eslint parser and plugins, then enable rules that enforce strict type checking across .ts and .tsx files. This catches type-related violations during linting and maintains consistency with your strict TypeScript configuration for robust, maintainable code.

How do I handle null and undefined safely in TypeScript?

Null handling in TypeScript uses strict null checks combined with type guards—conditional checks that verify a value exists before use. Patterns include optional chaining, nullish coalescing, and explicit type narrowing with if statements or discriminated unions to prevent null reference errors.

Can I apply type-safe patterns across both JavaScript and TypeScript files?

Yes, ESLint and type-checking patterns apply to .js, .jsx, .ts, and .tsx files. While TypeScript provides compile-time checks in .ts files, ESLint can enforce type-safety conventions in JavaScript files using JSDoc annotations and linting rules for consistent code quality across your mixed project.

What are discriminated unions and when should I use them?

Discriminated unions are TypeScript types that combine a literal field with variant types, enabling exhaustive type checking. Use them when handling multiple related object shapes—like API responses or state machines—to ensure all cases are handled and catch missing branches at compile time.

Why does strict TypeScript configuration matter for large projects?

Strict TypeScript configuration catches type errors early, reducing bugs in production and maintenance burden. For scalable projects, it enforces uniform type discipline across teams, prevents unsafe patterns, and makes refactoring safer by ensuring type contracts are upheld throughout the codebase.