typescript-core

Enforces strict typing and safe refactors in TypeScript projects.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/ForeverWorld/curdx-ralph --skill typescript-core-foreverworld
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: typescript-core
Source: https://github.com/ForeverWorld/curdx-ralph/tree/main/skills/typescript-core
Command: npx skills add https://github.com/ForeverWorld/curdx-ralph --skill typescript-core-foreverworld

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps teams enforce strong typing in TypeScript projects, guiding safe refactors and better API contracts while avoiding runtime regressions.

Core Features & Use Cases

  • Enforce strict typing by preferring unknown over any and using discriminated unions.
  • Promote safe refactors with the satisfies operator and concise generics.
  • Ensure compile-time validation by guiding type-checks and boundary modeling in TS/TSX projects.

Quick Start

Start by applying strict typing to a TypeScript module and run the TypeScript compiler to validate type boundaries.

Frequently Asked Questions about typescript-core

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

FAQPage Schema
How do I enforce strict type safety and replace any with unknown in TypeScript?

Enforce strict type safety in TypeScript by preferring unknown over any to force explicit boundary validations. This approach guides safe refactors and ensures compile-time checks catch potential runtime regressions across your data boundaries.

What is the best way to use discriminated unions for API contracts in TypeScript?

The best way to model API contracts in TypeScript is using discriminated unions to define explicit data shapes. This technique enforces strict typing at data boundaries, ensuring compile-time validation and safer refactoring for complex object structures.

Does TypeScript static analysis work with tsconfig and tsx files for boundary modeling?

TypeScript static analysis works directly with tsconfig configurations and tsx files to enforce boundary modeling. It validates type boundaries and API contracts across your project, ensuring strict compile-time type checks during development.

How do I minimize generics while maintaining strong typing in TypeScript projects?

Minimize generics in TypeScript projects by applying strict typing techniques like discriminated unions and the satisfies operator. This reduces generic complexity while maintaining strong API contracts and compile-time validation at data boundaries.

Why should I prefer unknown over any for boundary validations in TypeScript?

Prefer unknown over any in TypeScript because unknown forces explicit type checking at data boundaries. This prevents untyped data from silently causing runtime regressions, ensuring safe refactors and strict compile-time validation for API contracts.