Claude Code × TypeScript: Tips for Type-Safe Code Generation

const data = response.data as any
const user = data.user as any
const name = (data.user as any).name as string

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true
  }
}

## TypeScript Configuration

### Code generation rules
1. `as any` is banned. No exceptions.
2. `as Type` casting is only allowed after a type guard or Zod validation
3. All function parameters and return types must have explicit type annotations
4. Use `unknown` instead of `any`, then narrow with type guards
5. Rely on type inference where possible (excessive explicit annotations are also bad)

### Required verification
After generating any code, run `npx tsc --noEmit`.
Fix all type errors before submitting. Do not return code with type errors.

Generate a Zod schema from the following API response example.

API response example:
{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com",
  "role": "admin" | "user" | "guest",
  "createdAt": "2026-01-01T00:00:00Z",
  "profile": {
    "bio": "Developer",
    "avatarUrl": "https://example.com/avatar.jpg" | null
  }
}

Requirements:
- Type every field explicitly
- Define role as a union type
- Convert createdAt to Date using z.coerce.date()
- Mark nullable fields with .nullable()
- Export inferred types using z.infer<typeof Schema>

import { z } from 'zod'

const ProfileSchema = z.object({
  bio: z.string(),
  avatarUrl: z.string().url().nullable(),
})

const UserRoleSchema = z.enum(['admin', 'user', 'guest'])

export const UserSchema = z.object({
  id: z.number().int().positive(),
  name: z.string().min(1),
  email: z.string().email(),
  role: UserRoleSchema,
  createdAt: z.coerce.date(),
  profile: ProfileSchema,
})

export type User = z.infer<typeof UserSchema>
export type UserRole = z.infer<typeof UserRoleSchema>

Write a function that fetches user data and parses it with UserSchema above.

Requirements:
- Receive the response as unknown
- Throw ZodError on parse failure
- No `as any` casts

import { UserSchema, type User } from './schemas/user'

export async function fetchUser(userId: number): Promise<User> {
  const response = await fetch(`/api/users/${userId}`)

  if (!response.ok) {
    throw new Error(`Failed to fetch user: ${response.status}`)
  }

  const json: unknown = await response.json()
  return UserSchema.parse(json)
}

## Mandatory Check Before Submitting Code

After generating or modifying any code, always run `npx tsc --noEmit`.
Fix all type errors until the output shows zero errors.
Never return code that still has type errors.

{
  "scripts": {
    "type-check": "tsc --noEmit",
    "type-check:watch": "tsc --noEmit --watch"
  }
}

npx tsc --noEmit 2>&1

src/utils/parseResponse.ts:12:5 - error TS2322: Type 'any' is not assignable to type 'User'.
src/utils/parseResponse.ts:18:3 - error TS7006: Parameter 'data' implicitly has an 'any' type.

Found 2 errors.

Fix the following TypeScript errors.

Errors:
src/utils/parseResponse.ts:12:5 - error TS2322: Type 'any' is not assignable to type 'User'.
src/utils/parseResponse.ts:18:3 - error TS7006: Parameter 'data' implicitly has an 'any' type.

Fix approach:
- Do not use `as any`
- Use unknown type + type guards, or Zod validation
- Confirm `tsc --noEmit` shows zero errors before responding

Generate TypeScript + Zod schemas from the following OpenAPI spec.

Spec (excerpt):
---
components:
  schemas:
    Product:
      type: object
      required:
        - id
        - name
        - price
      properties:
        id:
          type: integer
        name:
          type: string
          maxLength: 100
        price:
          type: number
          minimum: 0
        category:
          type: string
          enum: [electronics, clothing, food]
        stock:
          type: integer
          nullable: true
---

Requirements:
- Export types using z.infer<typeof Schema>
- Reflect validation constraints (maxLength, minimum) in Zod
- Express nullable with .nullable()

## Prisma Type Rules (add to CLAUDE.md)

- Actively use Prisma-generated types (PrismaClient, Prisma.UserGetPayload, etc.)
- Import the User type from '@prisma/client', not custom definitions
- Use Prisma.UserGetPayload<{include: {posts: true}}> for query return types
- Do not override Prisma types with custom type definitions

import type { Prisma } from '@prisma/client'
import { prisma } from '@/lib/prisma'

type UserWithPosts = Prisma.UserGetPayload<{
  include: { posts: { include: { tags: true } } }
}>

export async function getUserWithPosts(userId: string): Promise<UserWithPosts | null> {
  return prisma.user.findUnique({
    where: { id: userId },
    include: {
      posts: {
        include: { tags: true },
      },
    },
  })
}

## TypeScript Type Safety Policy

### Absolute prohibitions
- Using `as any` (banned regardless of circumstances)
- Using `@ts-ignore` (`@ts-expect-error` is allowed with a comment explaining why)
- Function definitions without type annotations (parameters and return types are required)

### Typing external data
- Receive external API/JSON data as `unknown` and validate with Zod
- `response.json() as SomeType` casting is banned
- Export types from Zod schemas using `z.infer<typeof Schema>`

### tsconfig.json compliance
strict: true / noImplicitAny: true / strictNullChecks: true / noUncheckedIndexedAccess: true

### Required check (mandatory)
After generating or modifying code, run `npx tsc --noEmit` and confirm zero errors before responding.

### Zod conventions
- Centralize schema definitions in `src/schemas/`
- `.parse()` throws on validation failure (intentional behavior)
- Use `.safeParse()` when you need to handle errors gracefully
- Always export the inferred type alongside the schema