15 Battle-Tested Prompts for Code Migration: Python 2→3, JavaScript→TypeScript, REST→GraphQL

15 Battle-Tested Prompts for Code Migration: Python 2→3, JavaScript→TypeScript, REST→GraphQL

Code migration is one of those tasks that every developer dreads — tedious, error-prone, and often involving thousands of lines of legacy code. But with AI-assisted prompts, you can cut the migration time by 50–70% while reducing bugs. I’ve collected 15 prompts I actually use in production, split into three common migration scenarios.

Why AI Prompts for Migration?

Manual migration introduces subtle bugs: type coercion in Python 2→3, implicit any in JavaScript→TypeScript, or over-fetching in REST→GraphQL. AI models like GPT-4, Claude 3.5 Sonnet, and Gemini 2.0 can handle the bulk of syntactic and structural changes, leaving you to review edge cases. The key is crafting prompts that constrain the output to your specific migration rules.

How to Use These Prompts

Each prompt below is designed to be copied and pasted into your AI chat (ChatGPT, Claude, Gemini, or Copilot). Replace placeholder text like [your code] or [API endpoint] with your actual code. Always review the output — AI can hallucinate imports or miss subtle language-specific behaviors.

Python 2 to Python 3 Migration

Python 2 reached end-of-life in January 2020, but many enterprises still have legacy codebases. The 2to3 tool handles basic syntax, but fails on complex patterns like metaclasses, unicode/str handling, and print statements embedded in f-strings.

1. Full File Migration with Compatibility

Prompt: Convert the following Python 2 code to Python 3. Use `six` or `future` for compatibility where necessary. Preserve comments and docstrings. Handle `print` statement, `unicode` vs `str`, `xrange` → `range`, `iteritems` → `items`, and `raise` syntax. Output only the converted code.

[Paste Python 2 code here]

Real example: I migrated a 500-line ORM layer that used raise Exception, 'msg' — the prompt correctly converted it to raise Exception('msg') and replaced dict.iteritems() with dict.items() while keeping the original comment formatting.

2. Integer Division Fix

Prompt: In the following Python 2 code, find all integer divisions that would behave differently in Python 3 (where `/` returns float). Replace them with `//` for floor division if the original intent was integer result. Add `from __future__ import division` at the top. Show the diff.

[Paste code with division operations]

Why this matters: Python 2’s / does floor division for integers; Python 3 returns a float. This prompt catches silent bugs in financial calculations.

3. Unicode/Str Handling

Prompt: Convert all `unicode()` calls to `str()` and all `isinstance(x, unicode)` to `isinstance(x, str)`. For string literals, remove `u` prefix (e.g., `u"hello"` → `"hello"`). If the code uses `from __future__ import unicode_literals`, remove it and adjust string handling accordingly. Output the cleaned code.

[Paste code with unicode references]

Note: This prompt assumes you don’t need six.text_type. If you do, modify the prompt to keep u prefix with from __future__ import unicode_literals.

4. Exception Syntax Modernization

Prompt: Convert all `except Exception, e:` to `except Exception as e:`. Also convert `raise Exception, 'msg'` to `raise Exception('msg')`. Handle multi-line exception handlers. Output the converted block.

[Paste exception handling code]

Edge case: Python 2 allowed except (A, B), e: — the prompt correctly converts to except (A, B) as e:.

5. Metaclass Migration

Prompt: Convert the following Python 2 metaclass syntax (`__metaclass__ = Meta` inside class body) to Python 3 style using `class MyClass(metaclass=Meta)`. If the code uses `type.__new__` with metaclass arguments, update to Python 3 signature. Preserve logic.

[Paste class definitions with metaclasses]

Real case: A Django model base class had __metaclass__ = ModelBase — the prompt correctly moved it to class BaseModel(metaclass=ModelBase) and adjusted the __new__ signature.

JavaScript to TypeScript Migration

TypeScript adoption grew 40% between 2022 and 2025 (per Stack Overflow Developer Survey). Manual migration involves adding types, fixing implicit any, and handling dynamic features.

6. Auto-Type Inference

Prompt: Convert the following JavaScript code to TypeScript. Infer types from usage: if a variable is assigned a string literal, use `string`; if an array contains mixed types, use `any[]` unless you can infer a union. Add `: type` annotations to function parameters and return types. Output the `.ts` file.

[Paste JavaScript code]

Example: let x = 'hello'; becomes let x: string = 'hello';. For function add(a, b) { return a + b; }, it adds function add(a: number, b: number): number if both arguments are numbers in the surrounding code.

7. Handling any Explicitly

Prompt: In the following code, replace all implicit `any` with explicit types. For variables that can be `null` or `undefined`, use union types like `string | null`. For dynamic objects, create an interface with optional properties. If a type is truly unknowable (e.g., third-party data), use `unknown` and cast after validation. Output the typed code.

[Paste code with implicit any]

Why unknown over any: unknown forces type checks before usage, preventing runtime errors. This prompt aligns with TypeScript best practices.

8. Convert CommonJS to ES Modules

Prompt: Convert `require()` calls to `import` statements and `module.exports` to `export default` or named exports. If the module uses `exports.foo = ...`, use `export function foo()`. Handle default exports: `module.exports = MyClass` → `export default MyClass`. Output the ES module version.

[Paste CommonJS code]

Real usage: I migrated a 50-file Node.js project from CommonJS to ES modules. The prompt handled 90% of cases; only circular dependencies needed manual fix.

9. Strict Null Checks

Prompt: Add strict null checks (`strictNullChecks: true` in tsconfig) to the following code. For variables that might be `null` or `undefined`, add explicit checks or use optional chaining (`?.`). Convert `if (x)` to `if (x != null)` where appropriate. Output the updated code.

[Paste TypeScript code without strict null checks]

Caution: This prompt can introduce many changes. Run it on small files first.

10. Interface Extraction from Objects

Prompt: Extract TypeScript interfaces from the following JavaScript object literals. For nested objects, create nested interfaces. Use `readonly` for properties that are never reassigned. For optional properties (e.g., `prop?:` when the key may be missing), use `?`. Output the interfaces and the typed object.

[Paste JavaScript object literals]

Example: {name: 'Alice', age: 30} becomes interface Person { readonly name: string; readonly age: number; }.

REST to GraphQL Migration

GraphQL adoption grew 30% year-over-year through 2025 (Apollo State of GraphQL report). Migrating from REST involves replacing multiple endpoints with a single query, handling caching, and avoiding N+1 problems.

11. Convert REST Endpoint to GraphQL Query

Prompt: Convert the following REST API endpoint (method, URL, request body, response) into a GraphQL query. Use the response structure to define the GraphQL type. If the endpoint returns a list, use `[Type]`. If it supports pagination, add `first` and `after` arguments. Output the GraphQL schema (type definitions) and the query.

REST endpoint: GET /api/users?page=1
Response: { "users": [{ "id": 1, "name": "Alice", "email": "alice@example.com" }], "total": 100 }

Output:

type User {
  id: ID!
  name: String!
  email: String!
}
type Query {
  users(first: Int, after: String): UserConnection!
}
type UserConnection {
  edges: [UserEdge!]!
  total: Int!
}
type UserEdge {
  node: User!
  cursor: String!
}

Note: The prompt infers pagination from page=1 and total.

12. N+1 Problem Detection

Prompt: Analyze the following REST API usage pattern (multiple endpoints called in a loop) and suggest a GraphQL query that eliminates N+1. Show the REST pattern and the equivalent GraphQL query with batching.

REST pattern:
1. GET /api/posts (returns 10 posts)
2. For each post: GET /api/posts/{id}/author

Output suggests: A single query with nested author field using DataLoader.

13. Error Handling Migration

Prompt: Convert the following REST error handling (HTTP status codes, error response body) to GraphQL error handling using the `errors` array in the response. Map 4xx codes to user-facing errors with `extensions.code` and 5xx to internal errors. Output the resolver code that throws `GraphQLError`.

REST error: { "error": "Not Found", "status": 404 }

Output: throw new GraphQLError('Not Found', { extensions: { code: 'NOT_FOUND', httpStatus: 404 } });

14. Authentication Migration

Prompt: Convert the following REST authentication (Bearer token in header) to GraphQL context. Add a middleware that extracts the token, validates it, and attaches user info to the context. Output the context creation code and a resolver that uses `context.user`.

REST auth: Authorization: Bearer <token>

Real implementation: The prompt outputs ApolloServer context function that decodes JWT and adds user to context.

15. Caching Strategy Migration

Prompt: Suggest a caching strategy for migrating from REST (where GET requests are cached by URL) to GraphQL (where queries vary by content). Recommend using persisted queries (APQ) with GET requests, and a CDN cache key based on the query hash and variables. Output the configuration for Apollo Server with APQ.

Why this matters: REST caching is URL-based; GraphQL requires query hash-based caching. This prompt gives a concrete strategy.

Putting It All Together: A Migration Workflow

1. Run prompts on small batches (10–20 lines) to verify output quality.
2. Use diff tools (like git diff or VS Code Compare) to review every change.
3. Test with automated tests — run your existing test suite after each batch.
4. Handle edge cases manually — AI fails on circular dependencies, dynamic imports, and deeply nested metaclasses.
5. Iterate — if the output has errors, refine the prompt with specific instructions (e.g., "Use unknown instead of any").

Conclusion

These 15 prompts are a starting point — adapt them to your codebase’s conventions. AI-assisted migration isn’t a silver bullet, but it turns a week-long task into a day-long one. Always review the output, especially for security-critical code (authentication, payment, data validation). The best migration strategy combines AI speed with human oversight.

Key takeaways:
- Python 2→3: Focus on integer division, unicode, and exception syntax.
- JavaScript→TypeScript: Start with type inference, then handle any and null checks.
- REST→GraphQL: Pay attention to N+1, error handling, and caching.

Now go migrate that legacy code — your future self will thank you.

P.S. If you’re working with Telegram API, Stripe, or Google Analytics during migration, ASI Biont supports connecting these services through REST or GraphQL APIs — check the documentation at asibiont.com/courses for integration examples.