Last month I accidentally paid for both ChatGPT Plus and Claude Pro on the same day. My wife saw the credit card statement and asked why I was spending $40/month on “robot friends.” Fair question.

The real answer is that I use both of them constantly, for different things, and neither one is good enough to replace the other. I’ve been going back and forth for about a year now — I lead a team that builds real-time data processing systems, and these tools have become part of how I work. Not in a “the future is here” way, more in a “this saves me 20 minutes on a boring task” way.

Here’s where I’ve landed after a year of daily use.

Coding: The Thing You Actually Care About

ChatGPT is faster for “just get it done” tasks

When I need a quick utility script — pull data from an API, parse some logs, generate a migration — ChatGPT tends to nail it on the first try. It knows an absurd number of frameworks and APIs. I once asked it to write a script that fetches CloudWatch log groups and calculates error rates by service, and it produced something I could run with zero edits:

import boto3
from collections import defaultdict
from datetime import datetime, timedelta

def get_error_rates(log_group_prefix="/ecs/", hours_back=24):
    client = boto3.client('logs')
    end_time = int(datetime.now().timestamp() * 1000)
    start_time = int((datetime.now() - timedelta(hours=hours_back)).timestamp() * 1000)
    
    error_counts = defaultdict(lambda: {"errors": 0, "total": 0})
    
    paginator = client.get_paginator('describe_log_groups')
    for page in paginator.paginate(logGroupNamePrefix=log_group_prefix):
        for group in page['logGroups']:
            name = group['logGroupName']
            response = client.start_query(
                logGroupName=name,
                startTime=start_time,
                endTime=end_time,
                queryString='stats count(*) as total, sum(level="ERROR") as errors by bin(1h)'
            )
            # ... process results
    return error_counts

That kind of breadth — knowing the boto3 paginator API, the CloudWatch query syntax, the right timestamp format — is where ChatGPT shines. It’s basically memorized every AWS SDK tutorial ever written.

Claude is better when the task is actually hard

I gave both models the same refactoring job: a 400-line event processing function that had grown into a monster over two years. Nested conditionals 6 levels deep, mixed sync and async, implicit dependencies between blocks. The kind of code where you open the file and immediately close it again.

ChatGPT extracted some methods and called it a day. Syntactically correct, structurally identical. Claude identified that the function was secretly three different things (validation, transformation, routing), proposed splitting it into a pipeline, and produced code that was genuinely easier to think about.

But — and this is important — Claude also has a bad habit of over-engineering. I’ve had it propose an abstract factory pattern when a dictionary lookup would do. When Claude gets ambitious, you sometimes spend more time pruning the solution than you would have spent writing a simpler one yourself.

The rate limiter test

I asked both to build a rate limiter with sliding window, token bucket, and Redis backing. Quick results:

ChatGPT: Working code in maybe 15 seconds. Clean sorted-set approach. Missed clock skew between Redis and the app server — the kind of bug that wouldn’t show up in testing but would absolutely show up at 3 AM.

Claude: Took about 25 seconds. Included the clock skew handling without me asking, added a Redis connection failure fallback. Also about 40% more code than necessary. I spent 10 minutes trimming it down.

Neither was production-ready out of the box. That’s basically the state of AI coding right now.

Context Windows: When 128K Isn’t Enough

Claude’s 200K token window vs ChatGPT’s 128K matters less than you’d think for everyday work. Most coding tasks fit comfortably in 128K.

Where it actually matters: I maintain a service with a 2,400-line core module. When I paste the whole thing into ChatGPT and ask questions about the bottom half of the file, it starts getting confused around the 80-90K token mark — repeating things it said earlier, contradicting itself, “forgetting” a function I referenced 30 messages ago. Claude handles the full file without breaking a sweat.

The bigger difference is conversation coherence. If I’m iterating on a design over 15-20 messages, Claude remembers what we decided in message 3. ChatGPT starts drifting around message 10, and by message 15 it’s sometimes suggesting approaches we already rejected.

Reasoning

OpenAI’s o1 is legitimately impressive for formal reasoning. I gave it a concurrency bug — a race condition between three goroutines and a buffered channel — and it traced through the execution paths and found the exact interleaving that caused the deadlock. I wouldn’t have found that without drawing a diagram.

Claude’s Opus reasons differently. It’s more… exploratory? Less step-by-step, more “here are the angles I’m considering.” For architecture decisions and system design, I actually prefer this. When I’m deciding between Redis Streams and Kafka for an event bus, I don’t need formal logic — I need someone to surface the tradeoff I haven’t thought about.

For algorithms: o1. For system design: Claude. For the other 90% of coding questions: doesn’t matter.

What Each One Gets Wrong

I should be upfront about what annoys me.

ChatGPT is confidently wrong more often. It’ll generate code that uses a library method that doesn’t exist, or that was deprecated two versions ago, and present it with complete certainty. I’ve shipped a bug to staging because I trusted a ChatGPT-generated API call that used a parameter the library had removed in v3. That was my fault for not checking, but ChatGPT didn’t exactly help by being so sure of itself.

Claude is cautious to a fault. It sometimes refuses requests that are obviously fine — I asked it to write a penetration testing script for our own servers and it gave me a lecture about responsible disclosure. It also hedges too much. “This approach might work, but you should also consider…” Sometimes I just want an answer, not a philosophy seminar.

Both hallucinate library APIs. Both write code that works in isolation but doesn’t fit your actual system. Both need you to actually read and understand every line they produce. If you’re copy-pasting without reading, you’re building on sand.

Pricing

Both cost $20/mo for the consumer plans. ChatGPT Plus gives you more stuff — DALL-E, browsing, plugins, GPTs. Claude Pro gives you deeper coding tools — Claude Code CLI is genuinely useful if you live in a terminal.

For API usage, Claude’s Sonnet is cheaper per token than GPT-4o for most workloads. The heavy models (Opus, o1) are both expensive. I’ve had months where API costs hit $170+ depending on how deep I go on a project.

If you can only pick one and you mostly write code: Claude. If you can only pick one and you do a mix of everything: ChatGPT. If you can swing $40/mo: both. They’re genuinely complementary.

What I Actually Do

My daily split:

ChatGPT for quick scripts, exploring unfamiliar APIs, anything needing web search, generating diagrams, and questions outside of coding.

Claude for code review (the terminal pipe workflow is hard to beat), complex refactoring, architecture discussions, long iterative conversations, and writing technical docs.

Is this split clean? No. There are days where Claude handles a quick script better, or ChatGPT gives a sharper architecture take. These tools are close enough that your prompting skill matters more than which model you’re talking to.

I’ll update this when GPT-5 or Claude 4 drops. Knowing this space, that could be next week.

You might also like

📦 Free: AI Code Review Prompt Pack — 10 prompts I use on 15+ PRs/week.

Newsletter: One practical AI workflow per week, plus templates I don’t publish here. Subscribe →