Refactor TypeScript 'any' to Strict Interfaces in 20 Minutes with AI

# Install type coverage tool
npm install -D type-coverage

# Run analysis
npx type-coverage --detail

// Before: Unclear what the API returns
function fetchUser(id: string): Promise<any> {
  return fetch(`/api/users/${id}`).then(r => r.json());
}

// Add logging wrapper
function fetchUser(id: string): Promise<any> {
  return fetch(`/api/users/${id}`)
    .then(r => r.json())
    .then(data => {
      // Log to console or file for AI analysis
      console.log('fetchUser response:', JSON.stringify(data, null, 2));
      return data;
    });
}

I have TypeScript code with `any` types. Generate strict interfaces from this runtime data.

**Requirements:**
- Use descriptive interface names
- Mark optional properties with `?`
- Infer union types from varied samples
- Add JSDoc comments for unclear fields

**Runtime sample:**
[paste your JSON from Step 2]

**Current code:**
[paste your function using `any`]

Generate the interface and updated function signature.

/**
 * User object returned from /api/users/:id endpoint
 */
interface User {
  id: string;
  email: string;
  name: string;
  /** ISO 8601 timestamp */
  createdAt: string;
  role: 'admin' | 'user' | 'guest';
  preferences?: {
    theme: 'light' | 'dark';
    notifications: boolean;
  };
}

// Updated function
async function fetchUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  return response.json(); // Now properly typed
}

// You have this mess
function processOrders(orders: any[]): any {
  return orders.map((order: any) => {
    return {
      total: order.items.reduce((sum: any, item: any) => sum + item.price, 0),
      status: order.status
    };
  });
}

Refactor this to use strict types. Here are 3 real order samples:

[paste 3 different JSON samples showing variations]

Generate interfaces for Order, OrderItem, and the return type.

interface OrderItem {
  id: string;
  name: string;
  price: number;
  quantity: number;
}

interface Order {
  id: string;
  items: OrderItem[];
  status: 'pending' | 'processing' | 'shipped' | 'delivered';
  customerId: string;
}

interface OrderSummary {
  total: number;
  status: Order['status']; // Reuse the union type
}

function processOrders(orders: Order[]): OrderSummary[] {
  return orders.map(order => ({
    total: order.items.reduce((sum, item) => sum + item.price * item.quantity, 0),
    status: order.status
  }));
}

// Instead of: data: any
type ApiResponse<T> = 
  | { success: true; data: T }
  | { success: false; error: string; code: number };

async function fetchUser(id: string): Promise<ApiResponse<User>> {
  try {
    const response = await fetch(`/api/users/${id}`);
    const data = await response.json();
    return { success: true, data };
  } catch (error) {
    return { 
      success: false, 
      error: error.message, 
      code: response.status 
    };
  }
}

// Usage with type narrowing
const result = await fetchUser('123');
if (result.success) {
  console.log(result.data.email); // TypeScript knows this is User
} else {
  console.error(result.error); // TypeScript knows this is string
}

import { z } from 'zod';

// Generate Zod schema (AI can help here too)
const UserSchema = z.object({
  id: z.string(),
  email: z.string().email(),
  name: z.string(),
  createdAt: z.string().datetime(),
  role: z.enum(['admin', 'user', 'guest']),
  preferences: z.object({
    theme: z.enum(['light', 'dark']),
    notifications: z.boolean()
  }).optional()
});

// Infer the TypeScript type from Zod schema
type User = z.infer<typeof UserSchema>;

async function fetchUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  const data = await response.json();
  
  // Runtime validation
  return UserSchema.parse(data); // Throws if data doesn't match
}

Convert this TypeScript interface to a Zod schema:

[paste your interface]

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    
    // Catch common mistakes
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true
  }
}

npx tsc --noEmit

npx type-coverage
# 85.12% type coverage

npx type-coverage
# 98.47% type coverage ✓

npm test -- --coverage

Refactor this function to remove `any`. Here's the runtime data it processes:

[concrete examples]

Requirements:
- Strict types
- Handle null/undefined
- Document complex fields

Make this code better
[dumps 500 lines]

# Find all files with 'any'
git grep -l ': any' src/ > files-to-refactor.txt

# Process in batches of 5-10 files
# Use AI for each batch with shared context

module.exports = {
  rules: {
    '@typescript-eslint/no-explicit-any': 'error',
    '@typescript-eslint/no-unsafe-assignment': 'error',
    '@typescript-eslint/no-unsafe-call': 'error'
  }
};

# .github/workflows/typecheck.yml
name: Type Safety
on: [pull_request]
jobs:
  typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npx tsc --noEmit
      - run: npx type-coverage --at-least 95

# Add to package.json scripts
"scripts": {
  "type-audit": "type-coverage --detail --at-least 95"
}

# Run monthly
npm run type-audit

export function processData(data: any): any {
  return data.items.map((item: any) => ({
    ...item,
    computed: calculate(item.values)
  }));
}

interface DataItem {
  id: string;
  values: number[];
  metadata?: Record<string, string>;
}

interface ProcessedItem extends DataItem {
  computed: number;
}

export function processData(data: { items: DataItem[] }): ProcessedItem[] {
  return data.items.map(item => ({
    ...item,
    computed: calculate(item.values)
  }));
}