Claude vs Gemini for Coding: Compared Side by Side

On a real coding task, both Claude and Gemini returned correct, working code. The difference our run exposed was not correctness, it was what you paid for it. Claude cost about four times as much as Gemini and wrote roughly twice the length, trading extra documentation and examples for the higher price. When two models both get the code right, that cost gap is the thing worth looking at.

The run

The whole setup behind the numbers:

Prompt: one Python coding task (below), asking for a function, a docstring, edge-case handling, and a complexity note.
Models: Claude claude-opus-5-5 and Gemini gemini-4-argon.
Settings: each model’s default, temperature 0.7, no system prompt, no extra context.
Keys: our own, calling each provider directly. One real run.

Prompt

Write a Python function merge_intervals(intervals) that takes a list of [start, end] integer pairs, merges all overlapping intervals, and returns the merged list sorted by start. Include a docstring and handle the empty-input and single-interval cases. Then briefly explain the time complexity.

The result, side by side

Claude (claude-opus-5-5)

Correct: yes
Cost: $0.0218
Speed: 9.0 seconds
Length: 1,068 tokens
Extras: detailed docstring, worked examples, a quick-check block, time and space complexity

Gemini (gemini-4-argon)

Correct: yes
Cost: $0.0051 (about 4x cheaper)
Speed: 7.0 seconds
Length: 490 tokens
Extras: type hints and a clear time-complexity note, more compact

Both used the same sort-then-sweep approach and both handled the empty and single-interval cases. Here is the core of each:

Claude (claude-opus-5-5)

def merge_intervals(intervals):
    """Merge overlapping intervals, sorted by start. Input is not modified."""
    if not intervals:
        return []
    if len(intervals) == 1:
        return [list(intervals[0])]
    sorted_intervals = sorted(intervals, key=lambda iv: iv[0])
    merged = [list(sorted_intervals[0])]
    for start, end in sorted_intervals[1:]:
        last = merged[-1]
        if start <= last[1]:
            last[1] = max(last[1], end)
        else:
            merged.append([start, end])
    return merged

Plus a full docstring with examples, a runnable check block, and both time and space complexity.

Gemini (gemini-4-argon)

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Merges overlapping intervals and returns a sorted list of intervals."""
    if len(intervals) <= 1:
        return intervals
    sorted_intervals = sorted(intervals, key=lambda x: x[0])
    merged = [sorted_intervals[0]]
    for current in sorted_intervals[1:]:
        if current[0] <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], current[1])
        else:
            merged.append(current)
    return merged

Plus type hints and a clear O(N log N) complexity note.

One real design difference to notice: Claude returns a fresh copy on the single-interval case, while Gemini returns the input list directly. Depending on your code, that aliasing may or may not matter. It is the kind of thing you only catch by reading both.

Insight: “Both correct” is the start of the comparison, not the end. When two models solve the task, the decision moves to what else matters to you:

Need thorough docs and examples to hand a teammate? The pricier, longer answer earns its cost.
Shipping the function into your own codebase? The leaner, cheaper one may be all you need.

Read the code, not just the pass or fail.

These results come from a specific run on 2026-11-02 on one defined task, using real models through a real pipeline. They show how each model performed on that task, not a general ranking of model quality, which depends entirely on your task and data. Run your own to see your numbers.

Run it on your own coding task

The free tool below opens with Claude and Gemini ready to go, and the prompt is editable:

Click Launch to open the notebook.
Swap in your own coding task and add your own API keys.
Read both answers side by side with their cost and speed, in about a minute.

Nothing is sent to our servers, and your keys stay on your machine.

Want to go further? At llmprover.pysolvr.com you can score the code against your own checks, compare up to 20 models at once, and see which part of your setup caused a weak answer.

Run as of 2026-11-02. Models and their prices change often, so run a fresh comparison to see today’s result on your own coding task.