Avoid Any

Purpose

Use this skill to remove unsafe any usage and preserve TypeScript's ability to detect mistakes. The goal is to make data contracts explicit without overcomplicating the code.

When to Use

Use this skill when:

• Code declares variables, parameters, return values, or collections as any.
• API responses, event payloads, or external data are untyped.
• Type assertions hide unsafe assumptions.
• A function can be expressed with generics instead of any.
• Strict TypeScript settings are enabled or being introduced.

Do

Use explicit domain types when the shape is known:

interface UserDto {
  id: string;
  name: string;
  enabled: boolean;
}

function mapUser(dto: UserDto): UserViewModel {
  return {
    id: dto.id,
    displayName: dto.name,
    isActive: dto.enabled,
  };
}

Use unknown for untrusted input, then narrow it:

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

Use generics when the function should preserve a caller-provided type:

function firstItem<T>(items: readonly T[]): T | undefined {
  return items[0];
}

Use narrow temporary types at integration boundaries:

type UnknownRecord = Record<string, unknown>;

Do Not

Avoid using any as a shortcut:

function mapUser(dto: any): any {
  return {
    id: dto.id,
    displayName: dto.name,
  };
}

Avoid unsafe assertions that skip validation:

const user = response as UserDto;

Avoid replacing any with broad types that still hide the contract:

const payload: object = response;

Use temporary any only when there is a clear boundary, migration reason, and follow-up path. Keep it local, documented by naming or surrounding context, and do not leak it through public APIs.

Review Checklist

• Public function parameters and return values do not use any.
• External data uses unknown until validated or mapped.
• Known data shapes are represented with interfaces, type aliases, or DTOs.
• Reusable utilities use generics instead of any.
• Type guards or schema validation protect untrusted inputs.
• Type assertions are narrow and justified.
• Temporary any usage is isolated and does not spread through the codebase.
• Tests cover mapper or guard behavior when runtime data can vary.

Expected Output

1. Locate unsafe any usage and identify the data boundary.
2. Replace any with the narrowest practical type.
3. Use unknown plus narrowing for untrusted input.
4. Add interfaces, DTOs, type guards, or generics where they improve safety.
5. Avoid broad rewrites that are unrelated to type safety.