typescript
pproenca/dot-skills
TypeScript performance, tsconfig, type errors, and async patterns optimization.
What is typescript?
Specialized skill for optimizing TypeScript compilation speed, configuring tsconfig.json, fixing type errors, and improving async/await patterns. Use this when working on type system performance, compiler configuration, module organization, or encountering TypeScript errors like TS2322 or TS2339.
- Optimize type system performance with explicit return types, simplified generics, and conditional type extraction
- Configure tsconfig.json for faster compilation with incremental builds, skipLibCheck, and isolatedModules
- Fix async patterns by avoiding loop awaits, using Promise.all, and deferring await calls
- Organize modules efficiently by eliminating barrel imports, circular dependencies, and using type-only imports
- Improve type safety with strictNullChecks, exhaustive checks, and type guards
- Manage memory leaks in closures, event listeners, and global state
How to install typescript
npx skills add https://github.com/pproenca/dot-skills --skill typescriptHow to use typescript
- 1.Identify the performance bottleneck: compilation speed, type errors, async patterns, or module organization
- 2.Locate the relevant rule category (type system, compiler config, async, modules, safety, memory, or runtime)
- 3.Review the specific rule's guidance and code examples in the referenced documentation
- 4.Apply the recommended change to your code or tsconfig.json
- 5.Measure the impact using tsc --diagnostics or build timing tools
Use cases
- Speeding up tsc compilation in large TypeScript projects by 50-90% with incremental builds and skipLibCheck
- Fixing type assignment errors (TS2322, TS2339) by adding explicit return types and using type guards
- Optimizing data-fetching code by replacing sequential awaits in loops with Promise.all for 2-10× improvement
- Configuring tsconfig.json for a new project with performance-first settings
- Refactoring deeply nested generic types and large union types that cause quadratic type-checking costs
- TypeScript developers optimizing build performance
- Backend engineers managing large codebases with slow compilation
- Frontend developers reducing bundle size and import costs
- DevOps/build engineers configuring tsconfig.json for CI/CD pipelines
- Code reviewers identifying async and type system anti-patterns
typescript FAQ
No. This skill focuses exclusively on performance optimization, type errors, and async patterns. It does not cover TypeScript fundamentals or framework-specific code (React, Angular, etc.).
Enabling incremental compilation and skipLibCheck in tsconfig.json typically yields 50-90% faster rebuilds. Adding explicit return types to exported functions improves declaration emit by 30-50%.
Rules are prioritized by impact: Type System Performance and Compiler Configuration are CRITICAL and should be addressed first, followed by Async Patterns and Module Organization (HIGH priority).
Start with CRITICAL rules in compiler configuration (incremental, skipLibCheck, isolatedModules) and type system (explicit return types, avoid deep generics). Then progressively apply HIGH and MEDIUM priority rules based on your specific bottlenecks.
No. This skill addresses compilation performance, type safety, and code organization. Testing patterns and framework-specific runtime behavior are out of scope.
Full instructions (SKILL.md)
Source of truth, from pproenca/dot-skills.
name: typescript description: TypeScript performance, tsconfig, type errors, async patterns — triggered when the user asks to "optimize TypeScript performance", "speed up tsc compilation", "configure tsconfig.json", "fix type errors", "improve async patterns", or encounters TS errors (TS2322, TS2339, "is not assignable to"). Also triggers on .ts, .tsx, .d.ts file work involving type definitions, module organization, or memory management. Does NOT cover TypeScript basics, framework-specific patterns, or testing.
TypeScript Best Practices
Comprehensive performance optimization guide for TypeScript applications. Contains 45 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.
When to Apply
Reference these guidelines when:
- Configuring tsconfig.json for a new or existing project
- Writing complex type definitions or generics
- Optimizing async/await patterns and data fetching
- Organizing modules and managing imports
- Reviewing code for compilation or runtime performance
Rule Categories by Priority
| Priority | Category | Impact | Prefix |
|---|---|---|---|
| 1 | Type System Performance | CRITICAL | type- |
| 2 | Compiler Configuration | CRITICAL | tscfg- |
| 3 | Async Patterns | HIGH | async- |
| 4 | Module Organization | HIGH | module- |
| 5 | Type Safety Patterns | MEDIUM-HIGH | safety- |
| 6 | Memory Management | MEDIUM | mem- |
| 7 | Runtime Optimization | LOW-MEDIUM | runtime- |
| 8 | Advanced Patterns | LOW | advanced- |
Table of Contents
- Type System Performance — CRITICAL
- 1.1 Add Explicit Return Types to Exported Functions — CRITICAL (30-50% faster declaration emit)
- 1.2 Avoid Deeply Nested Generic Types — CRITICAL (prevents exponential instantiation cost)
- 1.3 Avoid Large Union Types — CRITICAL (quadratic O(n²) comparison cost)
- 1.4 Extract Conditional Types to Named Aliases — CRITICAL (enables compiler caching, prevents re-evaluation)
- 1.5 Limit Type Recursion Depth — HIGH (prevents exponential type expansion when applicable)
- 1.6 Prefer Interfaces Over Type Intersections — CRITICAL (2-5× faster type resolution)
- 1.7 Simplify Complex Mapped Types — HIGH (reduces type computation by 50-80% when applicable)
- Compiler Configuration — CRITICAL
- 2.1 Configure Include and Exclude Properly — CRITICAL (prevents scanning thousands of unnecessary files)
- 2.2 Enable Incremental Compilation — CRITICAL (50-90% faster rebuilds)
- 2.3 Enable isolatedDeclarations for Parallel Declaration Emit — CRITICAL (enables parallel .d.ts generation without type-checker)
- 2.4 Enable skipLibCheck for Faster Builds — CRITICAL (20-40% faster compilation)
- 2.5 Enable strictFunctionTypes for Faster Variance Checks — CRITICAL (enables optimized variance checking)
- 2.6 Use erasableSyntaxOnly for Node.js Native TypeScript — HIGH (prevents 100% of Node.js type-stripping runtime errors)
- 2.7 Use isolatedModules for Single-File Transpilation — CRITICAL (80-90% faster transpilation with bundlers)
- 2.8 Use Project References for Large Codebases — CRITICAL (60-80% faster incremental builds)
- Async Patterns — HIGH
- 3.1 Annotate Async Function Return Types — HIGH (prevents runtime errors, improves inference)
- 3.2 Avoid await Inside Loops — HIGH (N× faster for N iterations, 10 users = 10× improvement)
- 3.3 Avoid Unnecessary async/await — HIGH (eliminates trivial Promise wrappers and improves stack traces)
- 3.4 Defer await Until Value Is Needed — HIGH (enables implicit parallelization)
- 3.5 Use Promise.all for Independent Operations — HIGH (2-10× improvement in I/O-bound code)
- Module Organization — HIGH
- 4.1 Avoid Barrel File Imports — HIGH (200-800ms import cost, 30-50% larger bundles)
- 4.2 Avoid Circular Dependencies — HIGH (prevents runtime undefined errors and slow compilation)
- 4.3 Control @types Package Inclusion — HIGH (prevents type conflicts and reduces memory usage)
- 4.4 Use Dynamic Imports for Large Modules — HIGH (reduces initial bundle by 30-70%)
- 4.5 Use Type-Only Imports for Types — HIGH (eliminates runtime imports for type information)
- Type Safety Patterns — MEDIUM-HIGH
- 5.1 Enable noUncheckedIndexedAccess — MEDIUM-HIGH (prevents 100% of unchecked index access errors at compile time)
- 5.2 Enable strictNullChecks — MEDIUM-HIGH (prevents null/undefined runtime errors)
- 5.3 Prefer unknown Over any — MEDIUM-HIGH (forces type narrowing, prevents runtime errors)
- 5.4 Use Assertion Functions for Validation — MEDIUM-HIGH (reduces validation boilerplate by 50-70%)
- 5.5 Use const Assertions for Literal Types — MEDIUM-HIGH (preserves literal types, enables better inference)
- 5.6 Use Exhaustive Checks for Union Types — MEDIUM-HIGH (prevents 100% of missing case errors at compile time)
- 5.7 Use Type Guards for Runtime Type Checking — MEDIUM-HIGH (eliminates type assertions, catches errors at boundaries)
- Memory Management — MEDIUM
- 6.1 Avoid Closure Memory Leaks — MEDIUM (prevents retained references in long-lived callbacks)
- 6.2 Avoid Global State Accumulation — MEDIUM (prevents unbounded memory growth)
- 6.3 Clean Up Event Listeners — MEDIUM (prevents unbounded memory growth)
- 6.4 Clear Timers and Intervals — MEDIUM (prevents callback retention and repeated execution)
- 6.5 Use WeakMap for Object Metadata — MEDIUM (prevents memory leaks, enables automatic cleanup)
- Runtime Optimization — LOW-MEDIUM
- 7.1 Avoid Object Spread in Hot Loops — LOW-MEDIUM (reduces object allocations by N×)
- 7.2 Cache Property Access in Loops — LOW-MEDIUM (reduces property lookups by N× in hot paths)
- 7.3 Prefer Native Array Methods Over Lodash — LOW-MEDIUM (eliminates library overhead, enables tree-shaking)
- 7.4 Use for-of for Simple Iteration — LOW-MEDIUM (reduces iteration boilerplate by 30-50%)
- 7.5 Use Modern String Methods — LOW-MEDIUM (2-5× faster than regex for simple patterns)
- 7.6 Use Set/Map for O(1) Lookups — LOW-MEDIUM (O(n) to O(1) per lookup)
- Advanced Patterns — LOW
- 8.1 Use Branded Types for Type-Safe IDs — LOW (prevents mixing incompatible ID types)
- 8.2 Use satisfies for Type Validation with Inference — LOW (prevents property access errors, enables 100% autocomplete accuracy)
- 8.3 Use Template Literal Types for String Patterns — LOW (prevents 100% of string format errors at compile time)
References
Related skills
More from pproenca/dot-skills and the wider catalog.
ui-design
UI/UX and frontend design best practices guidelines (formerly frontend-design). This skill should be used when writing, reviewing, or designing frontend code to ensure accessibility, performance, and usability. Triggers on tasks involving HTML structure, CSS styling, responsive layouts, form design, animations, or accessibility improvements.
vitest
Vitest testing framework patterns: async, mocking, setup, snapshots, and performance optimization.
wxt-browser-extensions
WXT browser extension performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring WXT browser extension code to ensure optimal performance patterns. Triggers on tasks involving WXT, browser extensions, content scripts, service workers, messaging, and extension APIs.
zod
Zod schema validation best practices for type safety, parsing, and error handling.
powerpoint-ppt
Create, format, and manipulate PowerPoint presentations programmatically via MCP or python-pptx.
word-document
Word (.docx) manipulation via MCP server. Use for reading, creating, editing, formatting Word documents including tables, footnotes, comments, images, headers, styles, and PDF conversion.