typescript-strict-mode

Enforce strict TypeScript practices to eliminate any and promote explicit types.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/salesadriano/eventos --skill typescript-strict-mode-salesadriano
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: typescript-strict-mode
Source: https://github.com/salesadriano/eventos/tree/main/.github/agents/skills/typescript-strict-mode
Command: npx skills add https://github.com/salesadriano/eventos --skill typescript-strict-mode-salesadriano

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This guide helps teams eliminate unsafe any usage, strengthen type annotations, and harness TypeScript's type system to improve safety and maintainability across codebases.

Core Features & Use Cases

  • Avoid any by enforcing explicit types and using unknown when the type is truly unknown
  • Leverage generics, type guards, and utility types to model safer, reusable APIs
  • Integrate strict linting and TypeScript configuration to catch unsafe patterns early

Quick Start

Audit a TypeScript project for any usage of any, remove it where possible, and replace with precise types and guards.

Frequently Asked Questions about typescript-strict-mode

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

FAQPage Schema
How do I eliminate any from my TypeScript codebase?

Replace any with precise types or unknown when the type is truly undefined, and use type guards to safely narrow values down during runtime checks.

When should I use unknown instead of any in TypeScript?

Use unknown instead of any when the value type is genuinely uncertain, enforcing explicit type narrowing through type guards before any property access.

How do I configure ESLint and tsconfig for strict TypeScript type safety?

Configure strict linting rules and tsconfig compiler options to catch unsafe patterns early, prevent explicit any usage, and enforce explicit type annotations across the project.

What is the best way to use generics and utility types for safer TypeScript APIs?

Leverage generics and utility types to model reusable, type-safe APIs that enforce strict type checking, prevent unsafe casting, and improve overall code maintainability.

Does strict TypeScript type checking work across different frameworks?

Strict TypeScript practices apply universally across frameworks, enforcing explicit types, preventing any usage, and implementing type guards to ensure consistent type safety everywhere.

Why does TypeScript still allow unsafe operations in my project?

TypeScript allows unsafe operations when strict mode is disabled; enabling strict tsconfig options and ESLint rules eliminates any usage and enforces explicit type guards.