7 Free AIs Wrote the Same Correct Code. Whose Would You Trust?

In a companion experiment I gave seven free AI chatbots two invented coding problems, and every one of them scored a perfect ten out of ten, twice. Correctness turned out to be a dead heat. That left a more interesting question hanging. If the code all works, the only thing left to judge is the code itself. So I read all fourteen submissions the way I would read a colleague’s pull request, and they have surprisingly distinct personalities.

Two ways to sort the same thing

The clearest fault line ran right through round two, where the task was to sort characters by frequency and break ties by descending code point. Both directions were descending, so there were two clean ways to write it. Some models sorted a plain tuple with reverse turned on.

sorted(counts, key=lambda ch: (counts[ch], ord(ch)), reverse=True)

Others negated both keys instead.

sorted(counts, key=lambda c: (-counts[c], -ord(c)))

Both are correct here, so on the scoreboard they tie. But they are not equal. The reverse trick only works because both sort keys happen to run the same direction. The moment the spec wanted frequency descending but ties ascending, reverse falls apart and you would have to rewrite it, while the negation version just needs one sign flipped. The models that negated wrote code that survives a change of mind. It is a small thing, and it is exactly the kind of small thing that tells you who is thinking about the next requirement.

Claude and Perplexity: lean and clean

Claude wrote the code I would have been happiest to merge. Compact, no ceremony, the robust negation sort, and not a wasted line.

def dedup_ranked(s: str) -> str:
    s = s.replace(' ', '')
    if not s:
        return "EMPTY"
    counts = {}
    for c in s:
        counts[c] = counts.get(c, 0) + 1
    ranked = sorted(counts, key=lambda c: (-counts[c], -ord(c)))
    return ''.join(ranked)

Perplexity was cut from the same cloth, and arguably even leaner. It skipped the separate cleaning step entirely and filtered the spaces inline while counting. Minimal, elegant, correct.

DeepSeek: elegant, with one slip

DeepSeek mostly wrote lovely, spare code in the same lean spirit as Claude. But in round one it left a landmine. After the real return statement it added a second, unreachable return that referenced a variable which did not exist.

    return '-'.join(filtered[i:i+4] for i in range(0, len(filtered), 4))
    return result   # never runs, and 'result' was never defined

It never executes, so the tests passed. But a linter would flag it, and it is the kind of dead code that makes you wonder what else got left in. To DeepSeek’s credit, round two was spotless. Capable, and mostly elegant, but not perfectly consistent.

ChatGPT: verbose, and it trusts nothing

ChatGPT was the self-reliant one. In round one it refused to use isalnum and hand-wrote the character ranges. In round two it skipped Python’s built-in Counter and hand-rolled its own frequency dictionary. Both choices are perfectly correct, and both are more code than the job needed. If you like an assistant that spells everything out and leans on the language as little as possible, this is your model. If you value brevity, it will feel wordy.

Groq: the over-documenter

Groq wrote correct code and then buried it under paperwork. Its answer opened with a full docstring restating all six rules of the spec, followed by a step comment above nearly every line. Thorough, certainly. But I would side-eye it in a review. When the code is nine lines long, a nine line docstring plus a comment per line is noise, not clarity, and it is the habit of a tool trying to look diligent rather than be clear.

def dedup_ranked(s: str) -> str:
    """
    Transform s according to the specified rules:
    1. Remove all space characters.
    2. If the result is empty, return "EMPTY".
    3. Count each distinct character (case-sensitive).
    ... (all six rules, restated)
    """

Mistral and Gemini: small quirks

Mistral was fine, with one odd habit. It put its import statement inside the function body rather than at the top of the file. It works, but no seasoned Python developer writes it that way, and it is the sort of thing that quietly signals the model learned from a lot of code snippets rather than a lot of codebases. Gemini sat cleanly in the middle, readable and correct, though one of its comments described a negation the code did not actually use. A tiny drift between what it said and what it did.

This is the companion to the experiment itself, I built a coding gauntlet to trip up 7 free AI chatbots. For the researched comparison of the assistants behind them, see ChatGPT vs Gemini vs Claude.