sq-typescript

Enforce strict TypeScript with npx tsc --noEmit in React Native projects.

1|Updated Dec 7, 2025
One-click install
npx skills add https://github.com/treesus6/SkateQuest-Mobile --skill sq-typescript
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sq-typescript
Source: https://github.com/treesus6/SkateQuest-Mobile/tree/main/.claude/skills/sq-typescript
Command: npx skills add https://github.com/treesus6/SkateQuest-Mobile --skill sq-typescript

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enforces strict TypeScript across SkateQuest-Mobile to eliminate silent runtime type errors and ensure consistent, safe data shapes for components, API responses, and database typings.

Core Features & Use Cases

  • No any: replace any with unknown when dynamic, and narrow with type guards to prevent unsafe operations.
  • Explicit interfaces and types: prefer interface for objects and models, type for unions and aliases, ensuring predictable shapes across code.
  • Compile-time validation: run npx tsc --noEmit before completing a feature to catch type issues early.
  • Supabase row typing: derive row types from Database types to align UI with the backend schema.

Quick Start

Begin by adopting strict TypeScript patterns in a component and run npx tsc --noEmit to validate all typings.

Frequently Asked Questions about sq-typescript

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

FAQPage Schema
How do I enforce strict TypeScript in React Native to prevent runtime type errors?

Enforce strict TypeScript in React Native by replacing any with unknown, applying type guards, and running npx tsc --noEmit before completing features to catch type issues early. This prevents silent runtime type errors across components and APIs.

What's the best way to derive Supabase row types for TypeScript components?

Derive Supabase row types directly from Database types to align your UI components with the backend schema. This ensures predictable data shapes and consistent type safety for API responses and database operations across your application.

When should I use interface versus type in strict TypeScript architecture?

Use interface for objects and models to ensure predictable shapes, and use type for unions and aliases. This strict TypeScript architecture distinction enforces consistent type safety and prevents unsafe operations across your codebase.

Why does running npx tsc --noEmit matter before declaring a feature complete?

Running npx tsc --noEmit performs compile-time validation to catch type issues early before declaring features complete. This strict TypeScript practice prevents silent runtime type errors and ensures consistent, safe data shapes for components and API responses.

Can I use unknown and type guards instead of any in React Native TypeScript?

Yes, replace any with unknown when handling dynamic data, then narrow types using type guards to prevent unsafe operations. This no-any discipline enforces strict TypeScript usage and eliminates silent runtime type errors in React Native and Expo projects.

Does strict TypeScript work with Expo and Supabase navigation types?

Strict TypeScript works with Expo and Supabase by enforcing type safety on navigation types, component props, and Supabase row types. Deriving types from backend schemas ensures consistent data shapes across your React Native application.