strong-types

Enforce strict typing across PHP, TypeScript, Python, C#, Kotlin, Go, Rust, and Swift codebases.

37|2|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/jpcaparas/skills --skill strong-types
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: strong-types
Source: https://github.com/jpcaparas/skills/tree/main/skills/strong-types
Command: npx skills add https://github.com/jpcaparas/skills --skill strong-types

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps developers eliminate type ambiguity and enforce strong typing in their code, leading to more robust and maintainable applications.

Core Features & Use Cases

  • Strong Typing Enforcement: Bans type ambiguity, such as fallback chains, escape hatches, and untyped signatures.
  • Language Support: Supports PHP, TypeScript, Python, C#, Kotlin, Go, Rust, Swift, and other typed languages.
  • Automated Analysis: Scans code for type-related issues using a helper script.

Quick Start

To use the strong-types skill, install it with the following command:

npx skills add jpcaparas/skills --skill strong-types

Frequently Asked Questions about strong-types

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

FAQPage Schema
How do I enforce strong typing and eliminate type ambiguity in my codebase?

To enforce strong typing and eliminate type ambiguity, you scan your code to identify and address fallback chains, escape hatches, and untyped signatures. This ensures strict type safety and maintainability across your project.

What programming languages are supported for static type analysis?

Static type analysis supports PHP, TypeScript, Python, C#, Kotlin, Go, Rust, and Swift. It scans these typed languages to identify type-related issues and enforce strict type safety.

How do I scan code for untyped signatures and escape hatches?

You scan code for untyped signatures and escape hatches by running a helper script. This automated analysis identifies type ambiguity and helps enforce strict typing across your codebase.

Does strong typing enforcement work with both dynamically and statically typed languages?

Yes, strong typing enforcement works with dynamically typed languages like Python and PHP, as well as statically typed languages like Go, Rust, and Swift, ensuring type safety across multiple environments.

What are escape hatches and fallback chains in type safety?

Escape hatches and fallback chains are patterns that introduce type ambiguity by bypassing strict typing rules. Identifying and addressing these issues eliminates untyped signatures and enforces robust type safety.

When should I use static analysis to enforce type safety?

You should use static analysis to enforce type safety when your codebase requires robust maintainability and strict typing. It eliminates type ambiguity by detecting untyped signatures and escape hatches.