typescript

TypeScript strict patterns and best practices. Trigger: When writing TypeScript code - types, interfaces, generics.

⭐12.5kstars🔀1.9kforks📁View on GitHub🕐Updated Jan 10, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill enforces strict TypeScript patterns and industry best practices to enhance type safety and code maintainability. It provides automated guidance on implementing robust coding standards, including const assertions, flat interfaces, and the elimination of 'any' types, ensuring your codebase remains clean, scalable, and error-free.

Use Cases

  • Refactoring legacy TypeScript projects to replace 'any' types with 'unknown' and implementing custom type guards for safer data handling.
  • Standardizing project architecture by enforcing flat interface structures and const-based enums to improve IDE intellisense and refactoring efficiency.
  • Optimizing type definitions using advanced utility types like Pick, Omit, and Record to create precise and reusable type mappings.
  • Ensuring clean code imports by enforcing the 'import type' syntax for better build performance and architectural clarity.
nametypescript
description>
TriggerWhen implementing or refactoring TypeScript in .ts/.tsx (types, interfaces, generics, const maps, type guards, removing any, tightening unknown).
licenseApache-2.0
authorprowler-cloud
version"1.0"
scope[root, ui]
auto_invoke"Writing TypeScript types/interfaces"
allowed-toolsRead, Edit, Write, Glob, Grep, Bash, WebFetch, WebSearch, Task

Const Types Pattern (REQUIRED)

// ✅ ALWAYS: Create const object first, then extract type
const STATUS = {
  ACTIVE: "active",
  INACTIVE: "inactive",
  PENDING: "pending",
} as const;

type Status = (typeof STATUS)[keyof typeof STATUS];

// ❌ NEVER: Direct union types
type Status = "active" | "inactive" | "pending";

Why? Single source of truth, runtime values, autocomplete, easier refactoring.

Flat Interfaces (REQUIRED)

// ✅ ALWAYS: One level depth, nested objects → dedicated interface
interface UserAddress {
  street: string;
  city: string;
}

interface User {
  id: string;
  name: string;
  address: UserAddress;  // Reference, not inline
}

interface Admin extends User {
  permissions: string[];
}

// ❌ NEVER: Inline nested objects
interface User {
  address: { street: string; city: string };  // NO!
}

Never Use any

// ✅ Use unknown for truly unknown types
function parse(input: unknown): User {
  if (isUser(input)) return input;
  throw new Error("Invalid input");
}

// ✅ Use generics for flexible types
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// ❌ NEVER
function parse(input: any): any { }

Utility Types

Pick<User, "id" | "name">     // Select fields
Omit<User, "id">              // Exclude fields
Partial<User>                 // All optional
Required<User>                // All required
Readonly<User>                // All readonly
Record<string, User>          // Object type
Extract<Union, "a" | "b">     // Extract from union
Exclude<Union, "a">           // Exclude from union
NonNullable<T | null>         // Remove null/undefined
ReturnType<typeof fn>         // Function return type
Parameters<typeof fn>         // Function params tuple

Type Guards

function isUser(value: unknown): value is User {
  return (
    typeof value === "object" &&
    value !== null &&
    "id" in value &&
    "name" in value
  );
}

Import Types

import type { User } from "./types";
import { createUser, type Config } from "./utils";