Which LLM Is Best for Coding Right Now?

Why 'Which LLM Is Best?' Is the Wrong Question

You've probably felt it: a new "best coding model" headline every few weeks, each one contradicting the last. You pick one, and by the time you've wired it into your workflow, the leaderboard has reshuffled. The market is saturated, fast-moving, and — increasingly — unrankable in the way we're used to.

That's because the field hit a structural turning point. SWE-bench Verified, long the gold standard for coding evaluation, was archived on September 1, 2026 after three models from three different labs landed within a single point of each other — and within four points of the benchmark's ceiling. When a metric stops discriminating between frontier models, it stops being useful for making decisions.

So the real question has changed. It's no longer "which LLM is best for coding?" It's best for what task, in which harness, at what price. The harness part matters more than most people realize: the same model weights can score dramatically differently depending on the tooling wrapped around them. GPT-5.5's Terminal-Bench score, for example, jumps to 83.4% when run inside OpenAI's Codex CLI rather than the public Terminus-2 harness — same model, different plumbing, different result.

Here's the honest answer as of right now, with the usual caveat that leaderboards disagree:

• Claude leads most rankings. Claude Opus 5.5 tops the composite LLM Stats score at 60.7, and Claude Opus 5 holds the most coding-arena wins at 27.
• But no model wins unanimously. GPT-6 Astra leads the Terminal-Bench 4.0 agent leaderboard at 58.2% running in the Codex harness — a leaderboard where Opus 5.5 has no agent entry yet.
• Even reviewers who prefer one model decline to crown it absolutely. DataCamp names Opus 5.5 "best overall for agentic coding" while explicitly refusing to call Astra a clear loser.

The practical takeaway: treat any single leaderboard as one data point, and evaluate model-plus-harness combinations against your actual tasks rather than chasing a mythical overall winner.

One more layer compounds the confusion: the surrounding ecosystem matters as much as the model itself. Agent skills — the instruction packages that shape how these models behave on specific tasks — vary wildly in quality, and published research suggests roughly 26% carry at least one vulnerability. That's exactly the problem SkillzBench is being built to solve: a free, independent directory that security-scans, version-pins, and benchmarks every skill so you can see its measured Lift before trusting it. If you want to know when it goes live, the waitlist is open.

Pick your model deliberately. Pick your harness even more deliberately. And pick your skills with evidence, not vibes.

The Leaderboard, As Reported: What the Numbers Actually Say

The leaderboard looks decisive until you read the footnotes. Every credible source agrees on one thing: there is no single winning model, only winning combinations of model, harness, and price.

Anthropic's Claude family leads most coding rankings. According to LLM Stats' composite tracking, Claude Opus 5.5 holds the top score at 60.7, with Sonnet 5.5 at 58.7 and GPT-6 Astra at 58.5 — and Claude Opus 5 owns the most coding-arena wins at 27. DataCamp names Opus 5.5 "best overall for agentic coding," citing an 89.9% vendor-reported SWE-bench Pro score and $4/$20 per million tokens, while declining to crown Astra a clear winner.

The counter-evidence matters just as much. GPT-6 Astra tops the Terminal-Bench 4.0 agent leaderboard at 58.2% under the Codex harness, with 96.0% GPQA Diamond and a 1.1M context window. Opus 5.5 has no agent entry there yet — a reminder that leaderboards measure different things.

Budget and open-weight picks round out the picture:

• Gemini 3.8 Flash: Terminal-Bench 2.1 at 89.4%, $0.75/$3.75 per M tokens
• DeepSeek V4.1 Flash: Terminal-Bench 2.1 at 90.6%, $0.60/M output off-peak
• Kimi K3: best open-weights model at 93.5% GPQA, priced $3.39
• Qwen3.8-27B: best local model on a 24 GB GPU, 73.0% Terminal-Bench 2.1
• Claude Fable 5.1: SWE-bench Pro 81.2% vendor-reported, $10/$50 per M tokens

DataCamp's methodology tip is the soundest practice reported: treat vendor tables as best-case scenarios — their harness, their effort setting — and don't believe gaps under 3 points without independent replication on Artificial Analysis, Vals AI, or tbench.ai. Benchmark saturation backs this up. SWE-bench Verified was archived on September 1, 2026, after three models from three labs landed within one point of each other.

The practical takeaway: test model-plus-harness combinations, not models alone. And note that individual gains hit organizational ceilings — high-AI-adoption teams merge 98% more PRs but see 91% longer review times.

Skills are where that gap gets addressed. SkillzBench is building a free directory and MCP connector that pins, scans, and benchmarks agent skills so you can see measured Lift before trusting one.

The Harness Matters as Much as the Model

The same model can score wildly different numbers depending on the harness wrapped around it. Anthropic's own launch footnote flagged that GPT-5.5 hits 83.4% on Terminal-Bench 2.1 inside OpenAI's Codex CLI, yet lands lower in the public Terminus-2 harness — same weights, different plumbing, different result (DataCamp's coding model breakdown captures this directly). The takeaway is blunt: a benchmark number without a harness label is almost meaningless.

That convergence matters because the three major tools — Claude Code, Codex, and Cursor — now ship the same surface area. Each one offers a CLI, editor integration, cloud agents, and MCP support, so the old terminal-versus-IDE split has effectively dissolved (Cosmic's head-to-head comparison walks through the parity). Picking a stack now means picking a workflow philosophy, not a category.

Budget math reinforces this. Turing College's analysis recommends three Pro seats at roughly $60/month across Claude Code Pro, Codex/ChatGPT Plus, and Cursor Pro over a single $100 Claude Max plan for most agentic work — and notes that 50% of funded learners on Max 6× hit Fable limits every week (their coding-agents guide documents the usage-wall reality). Sticker price is the least interesting number on the page.

Practitioners have already adapted. Andrej Karpathy described going from 80% manual coding to 80% agent coding in roughly a month, working with "agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations." Simon Willison's rule of thumb: "For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent." Pieter Levels runs Claude Code on his VPS overnight, letting it iterate while he sleeps.

A few practical patterns have emerged from this convergence:

• Test model-and-harness combinations together, not models in isolation
• Run two tools — an editor agent plus a terminal agent for long-horizon work
• Route cheap tasks to subagents running smaller models
• Budget for usage walls, not advertised token prices

The harness layer is also where skills, plugins, and MCP servers attach — and that ecosystem is messy enough to warrant verification before trusting it. Skills, proven. SkillzBench is building a free directory and MCP connector that pins every skill to a commit SHA, security-scans it, and benchmarks its Lift in a sandbox, so teams can browse and toggle skills per agent instead of guessing which ones actually help.

ctaText

The Hidden Costs: Security Gaps and the Productivity Paradox

AI coding tools look like a productivity miracle on paper, but the data tells a far messier story once you look past syntax.

The code these models produce is "syntactically correct and functionally reasonable," yet it consistently misses subtle security patterns: race conditions in auth checks, TOCTOU bugs, improper error handling around privileged operations. Broad system-prompt instructions like "always write secure code" "do almost nothing, beyond eating up a few extra tokens." What actually works are tightly scoped, example-rich skills that reference specific frameworks and show correct and incorrect patterns side by side.

The organizational numbers are even more sobering. A Faros AI telemetry study of more than 10,000 developers found that high-AI-adoption teams merge 98% more pull requests, but review time climbs 91%, average PR size balloons 154%, and bugs per developer tick up 9%. There is no significant correlation between AI adoption and company-level throughput or quality. MIT Sloan research on over 100,000 GitHub developers echoes the pattern: coding activity rises up to 180% cumulatively, yet actual releases grow only about 30%, with no lift in app downloads or reviews.

The bottleneck has simply moved downstream. As Faros AI frames it through Amdahl's Law, a system moves only as fast as its slowest link, and AI has shifted that link from typing to review, testing, and release coordination. MIT Sloan's researchers recommend shrinking teams and reskilling toward those downstream tasks rather than expecting headcount gains.

Three patterns separate teams that capture value from those drowning in unreviewed PRs:

• Treat review capacity as the constraint. If PR volume jumps 98% but review time jumps 91%, hiring more reviewers or automating triage matters more than picking a faster model.
• Replace vague security prompts with scoped skills. Concrete, framework-specific guidance with worked examples closes the gap that "write secure code" never will.
• Measure releases, not commits. Coding activity and shipped product diverge sharply once AI enters the workflow.

The practical fix for the security gap is the same shape as the fix for the productivity gap: stop relying on the model's general knowledge and start feeding it verified, maintained, benchmarked instructions. Published research has already found that roughly a quarter of community-shared agent skills carry at least one vulnerability, which is why curated, security-scanned, Lift-tested skill directories matter. SkillzBench is building exactly that: a free directory plus an MCP connector where every skill is version-pinned, security-scanned, and benchmarked in a sandbox with and without the skill, so teams can equip their agents with proven instructions instead of crossing their fingers.

Your Action Plan: Pick, Verify, and Equip

Knowing which LLM leads today is only half the battle — the other half is turning that knowledge into a workflow that actually ships software. Here is a five-step plan grounded in the evidence above.

Step 1: Default to a top-tier model, but verify independently. Claude Opus 5.5 is a sensible default for agentic coding — it tops the composite LLM Stats Score at 60.7 and is DataCamp's pick for "best overall for agentic coding". But treat vendor tables skeptically: the same methodology requires independent replication before believing any gap smaller than 3 points.

Step 2: Test model-plus-harness combinations, not models alone. The same weights score differently in different plumbing — GPT-5.5 jumps to 83.4% on Terminal-Bench 2.1 inside OpenAI's Codex CLI versus the public Terminus-2 harness. Since all three major tools now ship a CLI, editor integration, cloud agents, and MCP support, run your own bake-off on your actual tasks.

Step 3: Budget for usage walls, not sticker price. Turing College found 50% of funded learners on a $100 Max plan hit rate limits weekly, and recommends three Pro seats (~$60/month across Claude Code, Codex, and Cursor) instead. Also watch cost-per-task: Opus 5.5's $5.98/task barely beats Opus 5's $5.86 despite advertised savings.

Step 4: Invest in the bottlenecks AI creates. A telemetry study of 10,000+ developers found high-AI-adoption teams merge +98% more PRs but see +91% longer review times and +9% bugs per developer. Reallocate savings toward review, testing, and release processes — the slowest link now sets your pace.

Step 5: Adopt tightly scoped, framework-specific skills. Semgrep's practitioner research found that vague instructions like "always write secure code" do "almost nothing" — effective skills are concrete, example-rich, and framework-specific. The catch: skills need ongoing maintenance as frameworks and threats evolve, and published research found roughly 26% of skills carry at least one vulnerability.

That maintenance burden is exactly what SkillzBench is building to remove. The platform will crawl, dedupe, and verify skills — pinning every version to a commit SHA, security-scanning, license-checking, and benchmarking each one in a sandbox with and without the skill — then connect them to your agent through a free MCP connector. Instead of writing and maintaining your own skills:

• Browse a continuously updated directory of agent skills for Claude Code, Codex, Cursor, Gemini CLI, and chat-app agents
• Verify before you install: trust scores, security scans, and license checks on every listed skill
• Test skills free with published Lift measurements, so you see what actually helps
• Equip per-agent loadouts — your agent sees only the skills and tools you toggle on

Everything — the directory, benchmarks, MCP connector, and alerts — will be free. The MCP tool is currently in build, so join the waitlist at skillzbench.com to get access first.