type-safety-strict

Enforce strict static type checking and runtime boundary validation in TypeScript and Python codebases.

9|3|Updated Jun 13, 2026
One-click install
npx skills add https://github.com/Sir-chawakorn/sanook-cli --skill type-safety-strict
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: type-safety-strict
Source: https://github.com/Sir-chawakorn/sanook-cli/tree/main/skills/type-safety-strict
Command: npx skills add https://github.com/Sir-chawakorn/sanook-cli --skill type-safety-strict

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill resolves loose typing issues, eliminates unsafe escape hatches like any, and ensures your codebase adheres to strict static analysis standards without compromising runtime behavior.

Core Features & Use Cases

  • Strict Type Enforcement: Configures and enforces strict modes for TypeScript (tsc) and Python (pyright/mypy) to catch errors at compile-time.
  • Boundary Validation: Implements runtime schema validation using tools like Zod or Pydantic to ensure data integrity at system edges.
  • State Modeling: Replaces loose data structures with precise discriminated unions, generics, and branded types to prevent logic errors.

Quick Start

Run the type-safety-strict skill to identify and eliminate all any types and enable strict mode in the current project configuration.

Frequently Asked Questions about type-safety-strict

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

FAQPage Schema
How do I eliminate any types and enforce strict static typing in TypeScript?

To enforce strict static typing in TypeScript, configure the compiler's strict mode to catch errors at compile-time and remove all unsafe any type assertions from the codebase. This process prevents silent runtime failures.

What is the best way to validate external data boundaries in Python codebases?

The best way to validate external data boundaries in Python codebases is implementing runtime schema validation using tools like Pydantic. This ensures data integrity at system edges while maintaining strict static type checking.

How do I replace loose data structures with precise domain modeling in TypeScript?

Replace loose data structures with precise domain modeling in TypeScript by implementing discriminated unions, generics, and branded types. This prevents logic errors by enforcing rigorous static type checking across the codebase.

Does strict static type checking work with both TypeScript and Python?

Yes, strict static type checking works with both TypeScript and Python. It configures language-specific type checkers like tsc for TypeScript and pyright or mypy for Python to catch errors at compile-time.

Why does my code still have silent runtime failures after enabling strict mode?

Silent runtime failures persist after enabling strict mode because static type checking alone cannot validate external data. You must integrate schema-based runtime validation using Zod or Pydantic at all system boundaries.