Claude Sonnet 4.6 vs GPT-5.5 for coding — honest comparison after 6 weeks

I've seen a lot of "Claude vs GPT" takes that are basically vibes dressed up as benchmarks. This isn't that. Over six weeks I ran both models on 30 specific tasks from my actual work — the same tasks, same prompts, same context. Here's what I found.

The setup

I'm a platform engineer. My tasks skew toward: Terraform/infrastructure as code, bash scripts, debugging distributed systems, writing internal tooling in Go and Python, and occasionally reviewing frontend code I don't fully understand.

I used NeonCodex for this test because it gives me access to both models in the same interface without switching tools.

For each task I'd run both models, then rate the output on: correctness (did it actually work), explanation quality (did I learn something), and time to useful (how many follow-ups before I got something I could use).

Where Claude wins

Complex debugging with context

For anything where I give a lot of context — logs, config files, relevant code — Claude consistently produces better root-cause analysis. It's better at holding all the pieces in mind and reasoning about their interaction.

Example: I had an intermittent timeout in a gRPC service. I gave both models the service code, the client code, the proto definition, the timeout config, and the logs. Claude identified that the timeout was happening specifically on stream-heavy calls and pointed to a buffer size mismatch between client and server. GPT-4o gave good generic advice about gRPC timeouts but didn't identify the specific issue.

Terraform and infra code

For some reason Claude is noticeably better at Terraform. Maybe training data, maybe reasoning about state and dependencies. I'd ask Claude to generate a VPC module with specific requirements and get something production-quality on the first try. GPT-4o would get the structure right but miss things like lifecycle rules, cross-region considerations, or provider version constraints that would cause issues later.

"Why is this bad" analysis

When I paste code and ask "what's wrong with this approach," Claude gives a more structured, thorough answer. It'll catch the security issue and the performance issue and the maintainability issue. GPT tends to lead with the most obvious thing.

Where GPT-5.5 wins

Speed

GPT-5.5 is faster. When I need a quick answer to something I'm pretty confident about, GPT gets me there in fewer tokens. Claude has a tendency to be thorough when I want fast.

Frontend and CSS

For anything touching React, CSS, or the browser — GPT-5.5 is better. Not by a huge margin but consistently. My guess: more frontend training data.

Following very specific formatting instructions

When I need output in a very specific format (like "give me this as a table with exactly these columns and then a JSON summary after"), GPT-5.5 is more reliable at following the format precisely. Claude sometimes diverges.

Writing style for non-technical content

For run books, postmortems, architecture docs — GPT produces more readable prose by default. Claude's writing is good but slightly more formal.

Tasks where they're basically the same

• Generating unit tests
• Writing SQL queries
• Simple bash scripts
• Explaining concepts
• Code review of small functions

For these I just use auto-routing and don't think about it.

The practical answer

If you're doing deep backend work, infrastructure, or complex debugging: use Claude Sonnet 4.6.

If you're doing frontend work, need fast answers, or care about precise output formatting: use GPT-5.5.

For everything else: auto-routing picks correctly about 80% of the time.

The mistake I made early was trying to pick one and stick with it. Having both available and routing by task type is genuinely better than being loyal to one model.

One thing that surprised me

I expected Claude to be worse at code generation and better at analysis. That's not quite right. Claude is actually very good at generating code — the quality is high — but it generates more code than you asked for. If I ask for a function, I get the function plus error handling plus tests plus a usage example. Sometimes that's great. Sometimes I just wanted the function.

GPT gives me exactly what I asked for and stops. Depending on the situation that's either better or worse.