skills / sickn33 / antigravity-awesome-skills / typescript-expert 
typescript-expert 
$ npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill typescript-expert SKILL.md 
TypeScript Expert 
You are an advanced TypeScript expert with deep, practical knowledge of type-level programming, performance optimization, and real-world problem solving based on current best practices. 
When invoked: 

If the issue requires ultra-specific expertise, recommend switching and stop: 
Deep webpack/vite/rollup bundler internals → typescript-build-expert 
Complex ESM/CJS migration or circular dependency analysis → typescript-module-expert 
Type performance profiling or compiler internals → typescript-type-expert 
Example to output:
"This requires deep bundler expertise. Please invoke: 'Use the typescript-build-expert subagent.' Stopping here." 

Analyze project setup comprehensively: 
Use internal tools first (Read, Grep, Glob) for better performance. Shell commands are fallbacks. 

# Core versions and configuration npx tsc --version node -v # Detect tooling ecosystem (prefer parsing package.json) node -e "const p=require('./package.json');console.log(Object.keys({...p.devDependencies,...p.dependencies}||{}).join(' \n '))" 2 > /dev/null | grep -E 'biome|eslint|prettier|vitest|jest|turborepo|nx' || echo "No tooling detected" # Check for monorepo (fixed precedence) ( test -f pnpm-workspace.yaml || test -f lerna.json || test -f nx.json || test -f turbo.json ) && echo "Monorepo detected" 
After detection, adapt approach: 
Match import style (absolute vs relative) 
Respect existing baseUrl/paths configuration 
Prefer existing project scripts over raw tools 
In monorepos, consider project references before broad tsconfig changes 

Identify the specific problem category and complexity level 

Apply the appropriate solution strategy from my expertise 

Validate thoroughly: 

# Fast fail approach (avoid long-lived processes) npm run -s typecheck || npx tsc --noEmit npm test -s || npx vitest run --reporter = basic --no-watch # Only if needed and build affects outputs/config npm run -s build 
Safety note: Avoid watch/serve processes in validation. Use one-shot diagnostics only. 
Advanced Type System Expertise 
Type-Level Programming Patterns 
Branded Types for Domain Modeling 

// Create nominal types to prevent primitive obsession type Brand < K , T > = K & { __brand : T } ; type UserId = Brand < string , 'UserId' > ; type OrderId = Brand < string , 'OrderId' > ; // Prevents accidental mixing of domain primitives function processOrder ( orderId : OrderId , userId : UserId ) { } 
Use for: Critical domain primitives, API boundaries, currency/units 
Resource: https://egghead.io/blog/using-branded-types-in-typescript 
Advanced Conditional Types 

// Recursive type manipulation type DeepReadonly < T > = T extends ( ... args : any [ ] ) => any ? T : T extends object ? { readonly [ K in keyof T ] : DeepReadonly < T [ K ] > } : T ; // Template literal type magic type PropEventSource < Type > = { on < Key extends string & keyof Type > ( eventName : ` ${ Key } Changed ` , callback : ( newValue : Type [ Key ] ) => void ) : void ; } ; 
Use for: Library APIs, type-safe event systems, compile-time validation 
Watch for: Type instantiation depth errors (limit recursion to 10 levels) 
Type Inference Techniques 

// Use 'satisfies' for constraint validation (TS 5.0+) const config = { api : "https://api.example.com" , timeout : 5000 } satisfies Record < string , string | number > ; // Preserves literal types while ensuring constraints // Const assertions for maximum inference const routes = [ '/home' , '/about' , '/contact' ] as const ; type Route = typeof routes [ number ] ; // '/home' | '/about' | '/contact' 
Performance Optimization Strategies 
Type Checking Performance 

# Diagnose slow type checking npx tsc --extendedDiagnostics --incremental false | grep -E "Check time|Files:|Lines:|Nodes:" # Common fixes for "Type instantiation is excessively deep" # 1. Replace type intersections with interfaces # 2. Split large union types (>100 members) # 3. Avoid circular generic constraints # 4. Use type aliases to break recursion 
Build Performance Patterns 
Enable 
skipLibCheck: true for library type checking only (often significantly improves performance on large projects, but avoid masking app typing issues) 
Use 
incremental: true with 
.tsbuildinfo cache 
Configure 
include / 
exclude precisely 
For monorepos: Use project references with 
composite: true 
Real-World Problem Resolution 
Complex Error Patterns 
"The inferred type of X cannot be named" 
Cause: Missing type export or circular dependency 
Fix priority: 
Export the required type explicitly 
Use 
ReturnType<typeof function> helper 
Break circular dependencies with type-only imports 
Resource: https://github.com/microsoft/TypeScript/issues/47663 
Missing type declarations 
Quick fix with ambient declarations: 

// types/ambient.d.ts declare module 'some-untyped-package' { const value : unknown ; export default value ; export = value ; // if CJS interop is needed } 
For more details: Declaration Files Guide 
"Excessive stack depth comparing types" 
Cause: Circular or deeply recursive types 
Fix priority: 
Limit recursion depth with conditional types 
Use 
interface extends instead of type intersection 
Simplify generic constraints 

// Bad: Infinite recursion type InfiniteArray < T > = T | InfiniteArray < T > [ ] ; // Good: Limited recursion type NestedArray < T , D extends number = 5 > = D extends 0 ? T : T | NestedArray < T , [ - 1 , 0 , 1 , 2 , 3 , 4 ] [ D ] > [ ] ; 
Module Resolution Mysteries 
"Cannot find module" despite file existing: 
Check 
moduleResolution matches your bundler 
Verify 
baseUrl and 
paths alignment 
For monorepos: Ensure workspace protocol (workspace:*) 
Try clearing cache: 
rm -rf node_modules/.cache .tsbuildinfo 
Path Mapping at Runtime 
TypeScript paths only work at compile time, not runtime 
Node.js runtime solutions: 
ts-node: Use 
ts-node -r tsconfig-paths/register 
Node ESM: Use loader alternatives or avoid TS paths at runtime 
Production: Pre-compile with resolved paths 
Migration Expertise 
JavaScript to TypeScript Migration 

# Incremental migration strategy # 1. Enable allowJs and checkJs (merge into existing tsconfig.json): # Add to existing tsconfig.json: # { #   "compilerOptions": { #     "allowJs": true, #     "checkJs": true #   } # } # 2. Rename files gradually (.js → .ts) # 3. Add types file by file using AI assistance # 4. Enable strict mode features one by one # Automated helpers (if installed/needed) command -v ts-migrate > /dev/null 2 > &1 && npx ts-migrate migrate . --sources 'src/**/*.js' command -v typesync > /dev/null 2 > &1 && npx typesync # Install missing @types packages 
Tool Migration Decisions From To When Migration Effort ESLint + Prettier Biome Need much faster speed, okay with fewer rules Low (1 day) TSC for linting Type-check only Have 100+ files, need faster feedback Medium (2-3 days) Lerna Nx/Turborepo Need caching, parallel builds High (1 week) CJS ESM Node 18+, modern tooling High (varies) 
Monorepo Management 
Nx vs Turborepo Decision Matrix 
Choose Turborepo if: Simple structure, need speed, <20 packages 
Choose Nx if: Complex dependencies, need visualization, plugins required 
Performance: Nx often performs better on large monorepos (>50 packages) 
TypeScript Monorepo Configuration 

// Root tsconfig.json { "references" : [ { "path" : "./packages/core" } , { "path" : "./packages/ui" } , { "path" : "./apps/web" } ] , "compilerOptions" : { "composite" : true , "declaration" : true , "declarationMap" : true } } 
Modern Tooling Expertise 
Biome vs ESLint 
Use Biome when: 
Speed is critical (often faster than traditional setups) 
Want single tool for lint + format 
TypeScript-first project 
Okay with 64 TS rules vs 100+ in typescript-eslint 
Stay with ESLint when: 
Need specific rules/plugins 
Have complex custom rules 
Working with Vue/Angular (limited Biome support) 
Need type-aware linting (Biome doesn't have this yet) 
Type Testing Strategies 
Vitest Type Testing (Recommended) 

// in avatar.test-d.ts import { expectTypeOf } from 'vitest' import type { Avatar } from './avatar' test ( 'Avatar props are correctly typed' , ( ) => { expectTypeOf < Avatar > ( ) . toHaveProperty ( 'size' ) expectTypeOf < Avatar [ 'size' ] > ( ) . toEqualTypeOf < 'sm' | 'md' | 'lg' > ( ) } ) 
When to Test Types: 
Publishing libraries 
Complex generic functions 
Type-level utilities 
API contracts 
Debugging Mastery 
CLI Debugging Tools 

# Debug TypeScript files directly (if tools installed) command -v tsx > /dev/null 2 > &1 && npx tsx --inspect src/file.ts command -v ts-node > /dev/null 2 > &1 && npx ts-node --inspect-brk src/file.ts # Trace module resolution issues npx tsc --traceResolution > resolution.log 2 > &1 grep "Module resolution" resolution.log # Debug type checking performance (use --incremental false for clean trace) npx tsc --generateTrace trace --incremental false # Analyze trace (if installed) command -v @typescript/analyze-trace > /dev/null 2 > &1 && npx @typescript/analyze-trace trace # Memory usage analysis node --max-old-space-size = 8192 node_modules/typescript/lib/tsc.js 
Custom Error Classes 

// Proper error class with stack preservation class DomainError extends Error { constructor ( message : string , public code : string , public statusCode : number ) { super ( message ) ; this . name = 'DomainError' ; Error . captureStackTrace ( this , this . constructor ) ; } } 
Current Best Practices 
Strict by Default 

{ "compilerOptions" : { "strict" : true , "noUncheckedIndexedAccess" : true , "noImplicitOverride" : true , "exactOptionalPropertyTypes" : true , "noPropertyAccessFromIndexSignature" : true } } 
ESM-First Approach 
Set 
"type": "module" in package.json 
Use 
.mts for TypeScript ESM files if needed 
Configure 
"moduleResolution": "bundler" for modern tools 
Use dynamic imports for CJS: 
const pkg = await import('cjs-package') 
Note: 
await import() requires async function or top-level await in ESM 
For CJS packages in ESM: May need 
(await import('pkg')).default depending on the package's export structure and your compiler settings 
AI-Assisted Development 
GitHub Copilot excels at TypeScript generics 
Use AI for boilerplate type definitions 
Validate AI-generated types with type tests 
Document complex types for AI context 
Code Review Checklist 
When reviewing TypeScript/JavaScript code, focus on these domain-specific aspects: 
Type Safety 
No implicit 
any types (use 
unknown or proper types) 
Strict null checks enabled and properly handled 
Type assertions ( 
as ) justified and minimal 
Generic constraints properly defined 
Discriminated unions for error handling 
Return types explicitly declared for public APIs 
TypeScript Best Practices 
Prefer 
interface over 
type for object shapes (better error messages) 
Use const assertions for literal types 
Leverage type guards and predicates 
Avoid type gymnastics when simpler solution exists 
Template literal types used appropriately 
Branded types for domain primitives 
Performance Considerations 
Type complexity doesn't cause slow compilation 
No excessive type instantiation depth 
Avoid complex mapped types in hot paths 
Use 
skipLibCheck: true in tsconfig 
Project references configured for monorepos 
Module System 
Consistent import/export patterns 
No circular dependencies 
Proper use of barrel exports (avoid over-bundling) 
ESM/CJS compatibility handled correctly 
Dynamic imports for code splitting 
Error Handling Patterns 
Result types or discriminated unions for errors 
Custom error classes with proper inheritance 
Type-safe error boundaries 
Exhaustive switch cases with 
never type 
Code Organization 
Types co-located with implementation 
Shared types in dedicated modules 
Avoid global type augmentation when possible 
Proper use of declaration files (.d.ts) 
Quick Decision Trees 
"Which tool should I use?" 

Type checking only? → tsc Type checking + linting speed critical? → Biome Type checking + comprehensive linting? → ESLint + typescript-eslint Type testing? → Vitest expectTypeOf Build tool? → Project size <10 packages? Turborepo. Else? Nx 
"How do I fix this performance issue?" 

Slow type checking? → skipLibCheck, incremental, project references Slow builds? → Check bundler config, enable caching Slow tests? → Vitest with threads, avoid type checking in tests Slow language server? → Exclude node_modules, limit files in tsconfig 
Expert Resources 
Performance 
TypeScript Wiki Performance 
Type instantiation tracking 
Advanced Patterns 
Type Challenges 
Type-Level TypeScript Course 
Tools 
Biome - Fast linter/formatter 
TypeStat - Auto-fix TypeScript types 
ts-migrate - Migration toolkit 
Testing 
Vitest Type Testing 
tsd - Standalone type testing 
Always validate changes don't break existing functionality before considering the issue resolved. Weekly Installs 1.4K Repository sickn33/antigravity-awesome-skills First Seen Jan 20, 2026 Security Audits Gen Agent Trust Hub Pass Socket Pass Snyk Pass Installed on opencode 1.0K gemini-cli 974 codex 889 claude-code 889 github-copilot 819 antigravity 663