typescript-pro

Audit TypeScript project configurations and enforce strict type safety.

68|6|Updated Apr 16, 2020
One-click install
npx skills add https://github.com/zenobi-us/dotfiles --skill typescript-pro
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: typescript-pro
Source: https://github.com/zenobi-us/dotfiles/tree/main/devtools/files/opencode/skills/typescript-pro
Command: npx skills add https://github.com/zenobi-us/dotfiles --skill typescript-pro

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solves? Complex TypeScript projects can suffer from type safety gaps, poor developer experience, and slow build times, leading to runtime errors and significant maintenance overhead.

Core Features & Use Cases

  • Advanced Type System Usage: Leverages conditional types, mapped types, and discriminated unions for robust, flexible APIs.
  • Full-Stack Type Safety: Ensures end-to-end type safety between frontend and backend using patterns like tRPC and GraphQL code generation.
  • Build Optimization: Optimizes tsconfig.json, project references, and module resolution for faster compilation and smaller bundles.
  • Use Case: Your large-scale React application needs improved type safety and faster build times. Use this Skill to refactor your codebase with advanced conditional and mapped types, implement end-to-end type safety with tRPC, and optimize your tsconfig.json for incremental compilation.

Quick Start

Use the typescript-pro skill to review your project's tsconfig.json and suggest optimizations for strictness and build performance.

Frequently Asked Questions about typescript-pro

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

FAQPage Schema
How do I enforce strict mode and type safety across a TypeScript project?

Strict mode in TypeScript catches type errors at compile time by enabling strict compiler options in tsconfig.json. This Skill audits your configuration to enforce strict mode, eliminate implicit any types, and ensure 100% type coverage for public APIs, reducing runtime errors and improving code reliability across frontend and backend applications.

Can I implement end-to-end type safety between frontend and backend?

Yes. End-to-end type safety ensures your frontend and backend share type definitions, eliminating mismatches at API boundaries. This Skill applies patterns like tRPC and GraphQL code generation to maintain consistent types across your full-stack application, preventing type errors from propagating between layers.

What's the best way to optimize TypeScript build times and bundle size?

Optimize tsconfig.json settings, project references, and module resolution strategies to reduce compilation overhead and output size. This Skill analyzes your build configuration and tooling pipeline to identify bottlenecks, recommend incremental compilation setups, and generate smaller bundles for faster deployments.

How do I use advanced TypeScript types like conditional and mapped types?

Conditional types, mapped types, and discriminated unions enable flexible, type-safe APIs that adapt to different inputs. This Skill refactors your codebase to leverage these advanced patterns, improving developer experience while maintaining strict type checking and reducing the need for runtime assertions.

Does this work with monorepos and large-scale applications?

Yes. This Skill is designed for TypeScript monorepos and full-stack projects, auditing tsconfig.json, package.json, and build configurations across multiple packages. It enforces consistent type safety, ESLint/Prettier integration, and test coverage above 90% at scale, with source map generation and declaration file support.

What happens if my project has gaps in type coverage or missing type declarations?

Missing type declarations and partial coverage create maintenance overhead and runtime risks. This Skill identifies gaps in type safety, enforces 100% type coverage for public APIs, generates declaration files, and ensures no explicit any usage without justification, improving long-term maintainability.