JavaScriptTypeScriptintermediate

TypeScript Strict Type Refactoring Wizard

Eliminate 'any', unsafe type assertions, and type narrowing gaps with pure discriminated unions.

#typescript #type-safety #discriminated-unions #generics #refactoring

Compatibility & Specs

Compatible AI Models

ClaudeChatGPTMicrosoft Copilot

Last UpdatedMar 5, 2026

Customizable Variables1 parameters

Main Prompt Template1 Variable

92 words • 682 characters

You are an elite TypeScript Compiler & Type System Architect. Analyze this TypeScript code snippet that currently uses loose types, `any`, or unsafe `as` type assertions. Code to refactor: ```typescript [loose_typescript_code] ``` Requirements: 1. Completely eliminate `any`, `unknown` without guard, and dangerous `as Type` assertions. 2. Implement Discriminated Unions where branching logic or varied payloads exist. 3. Utilize User-Defined Type Guards (`value is TargetType`) where runtime checks occur. 4. Leverage Generics with `extends` constraints to retain exact argument types. 5. Provide a step-by-step breakdown of why each typing decision enhances runtime correctness.

Tip:Variables marked in purple brackets can be tailored below.

Customize Prompt

Fill in the variables below. Your customized prompt updates instantly in the browser — no AI API needed.

Parameters (1)* Indicates required field

Loose TypeScript Code*[loose_typescript_code]

Code containing any, loose objects, or unsafe assertions

1 parameters active

Live Customized OutputLive Preview

118 words

You are an elite TypeScript Compiler & Type System Architect. Analyze this TypeScript code snippet that currently uses loose types, `any`, or unsafe `as` type assertions. Code to refactor: ```typescript type ApiResponse = { status: string; data?: any; error?: string }; function processResult(res: ApiResponse) { if (res.status === 'success') { console.log(res.data.user.name); } else { console.error(res.error.toUpperCase()); } } ``` Requirements: 1. Completely eliminate `any`, `unknown` without guard, and dangerous `as Type` assertions. 2. Implement Discriminated Unions where branching logic or varied payloads exist. 3. Utilize User-Defined Type Guards (`value is TargetType`) where runtime checks occur. 4. Leverage Generics with `extends` constraints to retain exact argument types. 5. Provide a step-by-step breakdown of why each typing decision enhances runtime correctness.

Launch in:

ChatGPT Claude Gemini

How to Use This Prompt

Follow this 3-step workflow to extract high-signal responses from any compatible AI model.

1. Tailor the Parameters

Use the interactive customizer above to substitute the bracketed placeholders with your exact context, requirements, and constraints.

2. Send to AI Model

Copy the prompt and paste it into Claude, ChatGPT, Gemini, or Copilot. These models follow structured multi-step constraints reliably.

3. Review and Iterate

Review the output against the verified benchmark below. Follow up in the conversation to stress-test edge cases or refine tone.

Prompt Variables & Parameters

Reference breakdown of every dynamic variable embedded in this prompt template.

Placeholder	Parameter Name	Type	Status	Description & Guidance
[loose_typescript_code]	Loose TypeScript Code	textarea	Required	Code containing any, loose objects, or unsafe assertionsDefault: type ApiResponse = { status: string; data?: any; error?: string }; function processResult(res: ApiResponse) { if (res.status === 'success') { console.log(res.data.user.name); } else { console.error(res.error.toUpperCase()); } }

Example Execution & Benchmark Output

Sample input arguments and the verified AI response demonstrating expected quality and formatting.

Sample VariablesInputs

[loose_typescript_code]

type ApiResponse = { status: string; data?: any; error?: string }; ...

Expected AI ResponseVerified Result

### Refactored Type-Safe Architecture ```typescript interface SuccessResponse<T> { readonly status: 'success'; readonly data: T; } interface ErrorResponse { readonly status: 'error'; readonly error: string; readonly code?: number; } export type ApiResponse<T> = SuccessResponse<T> | ErrorResponse; // Type predicate guard export function isSuccessResponse<T>(res: ApiResponse<T>): res is SuccessResponse<T> { return res.status === 'success'; } interface UserProfile { readonly user: { readonly id: string; readonly name: string; }; } export function processResult(res: ApiResponse<UserProfile>): void { if (isSuccessResponse(res)) { // TypeScript automatically narrows `res` to SuccessResponse<UserProfile> console.log(res.data.user.name); } else { // TypeScript guarantees `error` exists and is a string console.error(res.error.toUpperCase()); } } ```

Best Use Cases

Scenarios and roles where this prompt produces maximum leverage.

Eliminating unsafe 'any' across corporate TypeScript repositories

Building type-safe API client SDKs

Designing complex state machines with compile-time exhaustiveness checking

Tips for Best Results

Techniques to elevate response fidelity

•Specify your exact runtime and dependency versions (e.g. Next.js 15, React 19, TypeScript 5.4) to eliminate outdated syntax hallucinations.
•Ask the model to enumerate potential runtime failure modes, concurrency issues, or null boundary states before generating code.
•Request idiomatic, type-safe solutions with clear unit test skeletons rather than monolithic scripts.

Common Mistakes to Avoid

Frequent failure modes and anti-patterns

•Pasting large unformatted code dumps without indicating the specific function or error you want analyzed.
•Deploying AI-generated code directly to production without verifying memory safety, edge cases, and security vulnerabilities.
•Omitting architectural constraints (such as SSR vs. client component boundaries or database indexing).