Claude 3.5 Sonnet vs GPT-4o for Refactoring Legacy Code: Which LLM Actually Understands Spaghetti Logic?

There is a specific brand of dread reserved for the moment you inherit a legacy codebase. You know the type: a sprawling, undocumented monolith written in PHP 5.6 or ancient Java, complete with global variables, deeply nested loops, and cryptic variable names like temp_x_final_v2.

When you are tasked with dragging this relic into the modern era, pasting snippets into an AI assistant seems like the obvious escape hatch. But legacy code is the ultimate test of what makes these models tick. It requires more than just knowing syntax; it demands deep structural comprehension and absolute precision.

We pitted two of the heavyweight LLMs against each other: Anthropic’s flagship /platforms/claude and OpenAI's /platforms/openai. We skipped the basic LeetCode brain-teasers and threw real, ugly, undocumented spaghetti logic at both models. Here is how they actually fared under pressure.

The Test: Deciphering the Spaghetti

To make this a fair fight, we fed both models a 400-line chunk of legacy legacy database migration logic. The code was riddled with bad habits from 2012: raw SQL queries vulnerable to injection, deeply nested if-else blocks (seven levels deep, to be precise), and zero inline comments.

We asked both models to achieve three goals: 1. Analyse and explain the business logic of the code. 2. Refactor the code to modern TypeScript using an ORM, maintaining exact functional equivalence. 3. Identify and fix any hidden security vulnerabilities or edge cases.

Round 1: Structural Comprehension

GPT-4o jumped into action with immense speed. Within seconds, it spat out a neatly formatted, bulleted list explaining what the code did. However, on closer inspection, its analysis was superficial. It identified that the script migrated user accounts, but it completely missed a crucial, nested logical fork that handled suspended accounts differently from deleted ones.

Claude 3.5 Sonnet took slightly longer to start generating its response, but the depth of its comprehension was immediately apparent. It didn't just list the features; it mapped out the state flow of the data. Claude flagged the suspended-user edge case immediately and explained why the original author had built that weird nested loop in the first place (likely to avoid a database locking issue that existed in older database versions).

Winner: Claude 3.5 Sonnet. It looks past the syntax to understand the developer's original intent.

Round 2: Code Quality and Safety

Translating legacy spaghetti into clean, modern TypeScript is where many LLMs trip up. They often write code that looks pretty but quietly drops critical business rules.

GPT-4o’s refactored TypeScript was highly modular and looked incredibly clean. It used modern syntax, extracted functions beautifully, and implemented the ORM correctly. However, it made a fatal error: it omitted a subtle timezone conversion step buried in the original SQL queries. If we had deployed GPT-4o’s code directly to production, database timestamps for thousands of users would have shifted by eight hours.

Claude 3.5 Sonnet’s output was marginally less styled but functionally flawless. It preserved the timezone offset, converted the raw queries into clean TypeORM transactions, and added explicit error handling for null values that the legacy code had previously ignored. Claude also did not assume we wanted to rewrite everything from scratch; it kept the core execution path logical and readable.

Winner: Claude 3.5 Sonnet. If you are deploying this to production, Claude's obsessive preservation of edge cases is non-negotiable.

Round 3: The Context Window and 'Brain-Drain'

Legacy refactoring is rarely a one-shot prompt. You need to keep feed-backing your compiler errors and database schemas to the model. This is where context windows and rate limits become the bottleneck.

GPT-4o has a generous 128k context window, which is more than enough for mid-sized files. However, during our multi-turn debugging session, GPT-4o started exhibiting "brain-drain" after about five prompts. It forgot that we had specified TypeORM and began suggesting Prisma code instead. When this happens, you can find yourself wasting time correcting the AI rather than writing code. If you hit persistent context errors with OpenAI's tools, checking the https://www.openai-support.com pages for model limits can clarify if you have crossed their dynamic rate ceilings.

Claude 3.5 Sonnet offers a massive 200k context window, managed via its Projects feature. In our testing, Claude retained instructions perfectly across 15 turns of conversation. It remembered our database schema, our styling preferences, and our strict rule against external utility libraries. When things do occasionally stall, Anthropic’s developer documentation and https://claude-support.com resources offer clear pathways to optimise your system prompts for massive codebases.

The Cost and Limit Comparison

If you are refactoring an entire repository, the cost of running API calls can add up quickly.

• GPT-4o: Priced at $2.50 per million input tokens and $10.00 per million output tokens. It is fast, cheap, and highly accessible.
• Claude 3.5 Sonnet: Priced at $3.00 per million input tokens and $15.00 per million output tokens. It is slightly more expensive, but the reduction in debugging time easily offsets the minor price premium.

The Verdict

For simple code translation or boilerplates, GPT-4o is a fast, cost-effective tool. But when you are dealing with legacy logic where a single missed edge case can bring down a production database, Claude 3.5 Sonnet is the clear victor.

Claude has a rare capacity to read between the lines of poorly written code, understand the messy reality of human developer behaviour, and produce clean, functionally identical modern code without losing its head halfway through the process.