TL;DR: Six months ago I published a Copilot-specific model guide. Almost every name on it has since been superseded. This mid-year update widens the lens beyond GitHub Copilot to every environment — Cursor, Codex, Windsurf/Devin, Claude Code, or a raw API — and gives each current model the same exhaustive best for / when to use / trade-offs / pro tip treatment. It covers the closed-source frontier (Anthropic, OpenAI, Google, xAI) and the open-weight surge (GLM, DeepSeek, Kimi, Qwen, MiniMax, Nemotron, Mistral) that has, this year, become genuinely production-grade.
Generated AI image by Google Gemini Nano Banana
Introduction
Back in January I wrote a guide to GitHub Copilot’s model picker — GPT-5, the early Claude 4 lineup, Gemini previews, and which to reach for when. That post aged in weeks, which six months on feels like the whole point of writing about this space.
Since then: Anthropic shipped Sonnet 5 and Opus 4.8, launched a new top tier (Fable 5), and had to pull that top model off the market for three weeks under a US export-control order before restoring it. OpenAI iterated through GPT-5.4, 5.5, and the GPT-5.6 “Sol / Terra / Luna” family, and merged its Codex and general-purpose stacks into one model. Google shipped Gemini 3.5 Flash but scrapped and rebuilt its next flagship from scratch. xAI turned Grok into a coding-first model co-trained with Cursor. And a cluster of open-weight labs — Z.ai’s GLM, DeepSeek, Moonshot’s Kimi, Alibaba’s Qwen, MiniMax, and NVIDIA’s Nemotron — closed the gap on the frontier to single benchmark digits while running at a fraction of the cost.
This time the post is not Copilot-specific. If you’re in Cursor, Codex, Windsurf, Claude Code, or straight through an API, the same models and trade-offs apply — only the interface changes. The discipline is the same as January: match the model to the task, not the task to whatever’s newest. There are just a lot more models now.
By the end you’ll understand:
- The current closed-source frontier and where each model earns its keep
- Which open-weight models are now genuinely production-viable, and for what
- A practical routing framework and a scenario-based playbook you can lift into your own team
A note on benchmarks before we start: I cite a few scores below (SWE-Bench Pro, Terminal-Bench, the Artificial Analysis Intelligence Index) as directional signals, not gospel. Several are vendor-reported, index methodologies changed mid-year (Artificial Analysis moved to v4.1 in June, which reshuffled a lot of open-weight numbers), and the only benchmark that truly matters is your own eval on your own codebase. Treat everything here as a starting shortlist, then verify.
Part 1: The Closed-Source Frontier
Anthropic
Claude Sonnet 5 (the new default)
Released June 30, 2026, Sonnet 5 replaced Sonnet 4.6 as the default across Free and Pro, and it’s the model most professional work should route to first. It matches Opus 4.8 on a lot of everyday knowledge-work and coding tasks at meaningfully lower cost.
Best for:
- Everyday coding, feature work, and refactors
- Code review and clean, well-reasoned review comments
- Production-grade output where quality matters but the task isn’t extreme
- Document comprehension and general reasoning
When to use:
- As your day-to-day default, full stop
- When you’d have reached for Opus out of habit but the task doesn’t truly need it
- Customer-facing or maintainability-sensitive code
Trade-offs:
- Introductory pricing ($2/M input, $10/M output through Aug 31, 2026; then $3/$15) — cheaper than Opus but not the cheapest option
- Its updated tokenizer maps the same input to roughly 1.0–1.35× more tokens than before, so budget on realized token counts, not old assumptions
- For genuinely long-horizon or architecturally gnarly work, it can visibly trail Opus
Pro tip: Make Sonnet 5 your default and only escalate when you can feel it struggling. The most common cost mistake in 2026 is reaching for the biggest model by reflex.
Claude Opus 4.8 (the deployable flagship)
Opus 4.8 is the heavyweight you can actually use today — the strongest generally-deployable Claude for hard reasoning and long-horizon agentic chains. On independent coding indices it sits at the top of the pack (~56 on Artificial Analysis’s coding measure, ahead of every open-weight model).
Best for:
- Long-horizon agentic work spanning many files, tests, and follow-up fixes
- The hardest architectural and debugging problems
- Repo-level coding where correctness across a large change matters
When to use:
- Sonnet 5 has visibly hit its ceiling on a task
- Mission-adjacent work where a wrong answer is expensive
- Multi-step agent runs that need to stay coherent over a long session
Trade-offs:
- $5/M input, $25/M output (Fast mode $10/$50) — roughly double Sonnet
- Slower than Sonnet and Haiku
- Overkill (and a budget drain) for routine work
Pro tip: Opus 4.8 has a 1M-token context window. Use it deliberately for whole-codebase reasoning, but don’t leave an agent parked on Opus for tasks Sonnet would clear — the output-token bill compounds fast.
Claude Haiku 4.5 (speed and scale)
Still the fast/cheap tier and more capable than its price suggests (“near-frontier” in Anthropic’s framing). At $1/M input, $5/M output it’s the cheapest Claude.
Best for:
- Real-time completion, boilerplate, syntax fixes, scaffolding
- High-volume, low-complexity tasks (classification, routing, extraction, summarization)
- Repetitive CRUD and standard patterns
When to use:
- You need instant feedback while typing
- Running a high-throughput pipeline where per-call cost dominates
- The task is well-defined and doesn’t need deep reasoning
Trade-offs:
- Not for architectural decisions or complex multi-step reasoning
- Less depth than Sonnet/Opus on ambiguous problems
Pro tip: Haiku is a superb first-pass and triage model. Let it draft, classify, or route, and escalate only the cases that actually need a bigger model.
Claude Fable 5 (the Mythos tier)
Fable 5 is the first model in Anthropic’s new “Mythos” tier, sitting above Opus. It launched June 9, was suspended worldwide on June 12 under a US Department of Commerce export-control directive, and was restored July 1 once the controls lifted. If it vanished from your tooling in June, that’s why. It’s back now at $10/M input, $50/M output.
Best for:
- The highest-stakes architecture and long-horizon planning
- Problems that genuinely stump Opus
- Repo-level coding at the frontier (it leads some repo-level coding measures)
When to use:
- Truly critical work where quality is the only metric and budget is secondary
- Deep architectural planning where you want the strongest available reasoning
Trade-offs:
- The most expensive option here, on premium usage-based billing
- Availability has a recent history of policy volatility — worth keeping a fallback (Opus 4.8) wired up in production
- Mythos 5, its sibling, remains limited to approved partners
Pro tip: Treat Fable 5 the way January’s post treated Opus — the big gun, used sparingly. For most “hard” tasks, Opus 4.8 gets you there for half the price.
OpenAI
OpenAI’s naming moved fast this year (5.2 → 5.4 → 5.5 → 5.6). The two things that matter for developers: the GPT-5.6 family split into three durable tiers, and the Codex and general-purpose stacks merged.
GPT-5.6 Sol (flagship)
Launched July 9, 2026, Sol is the top tier — built for frontier reasoning and long-horizon agentic work. It leads on agentic/terminal benchmarks (strong BrowseComp, OSWorld, and Terminal-Bench numbers) and, notably, does so using fewer output tokens than many rivals.
Best for:
- Long-horizon coding agents that persist across files, tests, and fixes
- Complex multi-file debugging and architecture decisions
- Security-sensitive review and cybersecurity research
- Terminal-heavy, tool-coordination-heavy agent runs
When to use:
- The task needs max reasoning or “ultra” mode
- You’re on GPT-5.5 or older and doing serious agentic coding — this is the upgrade
- Escalation target for the hardest work in a tiered setup
Trade-offs:
- $5/M input, $30/M output — same input price as GPT-5.5, premium output
- Only Sol supports the deepest reasoning effort levels
- Overkill for routine work
Pro tip: Sol’s edge is token efficiency at depth — it stays oriented on long tasks and does the unglamorous follow-through. Reserve it for the runs where that persistence pays for the output price.
GPT-5.6 Terra (balanced)
The mid tier at $2.50/M input, $15/M output — positioned as the everyday business default.
Best for:
- Scoped implementation and first-pass code review
- Large-scale business workflows: support, internal tools, document analysis
- The main execution lane in a routed system, with Sol as escalation
When to use:
- Everyday coding and research that doesn’t need Sol-level depth
- You’re currently on GPT-5.4 — Terra replaces it at the same price with better scores
Trade-offs:
- Here’s the honest catch: several independent analyses find Terra rarely sits on the cost-performance frontier — for many effort levels, a Luna or Sol setting gives you either better quality at the same price or the same quality cheaper
- “Safe middle” can mean “not optimal for either axis”
Pro tip: Don’t adopt Terra by default just because it’s the middle. Benchmark it against Luna-high and Sol-low on your tasks; sometimes the barbell (cheap Luna + occasional Sol) beats the middle.
GPT-5.6 Luna (fast and cheap)
The lightweight tier at $1/M input, $6/M output, performing near GPT-5.5 on several tests despite the low price.
Best for:
- High-volume, low-complexity work: summaries, drafting, routing, monitoring, labeling
- The repetitive layer of an agentic system
- Simple coding and content tasks
When to use:
- Speed and cost are the primary constraints
- First-pass triage before deciding whether to escalate
Trade-offs:
- Falls short on deep reasoning, long-context retention, and nuance-critical output
- 8-point Intelligence Index gap to Sol — real for frontier problems, irrelevant for routine ones
Pro tip: Luna + Sol is a strong barbell: run the routine layer on Luna, route only the hard calls up to Sol, and you’ll often beat a Terra-everywhere setup on both cost and quality.
GPT-5.3-Codex (the unified coding model)
The structural shift for developers: GPT-5.3-Codex merged the Codex and general-purpose GPT-5 training stacks into one model — best-in-class code generation plus reasoning, about 25% faster than its predecessor. OpenAI called it its “first model instrumental in creating itself.” It’s the workhorse in the Codex CLI, IDE extension, and cloud.
Best for:
- Agentic, project-scale software engineering: refactors, migrations, long-running tasks with research and tool use
- Work where you’d previously have juggled “the reasoning model” and “the coding model”
- Long-horizon coding via context compaction across multiple windows
When to use:
- You live in Codex surfaces (CLI, IDE, cloud, code review)
- Large code changes that need to stay coherent over hours
Trade-offs:
- Codex-optimized; general chat isn’t its point
- A smaller GPT-5.3-Codex-Spark variant runs on Cerebras hardware at 1,000+ tokens/second for real-time coding — text-only, and a different point on the speed/depth curve
Pro tip: If you were context-switching between a “thinking” model and a “coding” model in your Codex workflow, stop — this collapses that decision into one. Use Spark for the tight inner loop, 5.3-Codex for the heavier changes.
Gemini 3.5 Flash (shipped and solid)
Announced at I/O in May and shipped the same day, Flash is Google’s available, high-volume workhorse (roughly $1.50/M input, $9/M output).
Best for:
- Fast iterations and high-volume agent pipelines
- Multimodal work (text + images + audio + video)
- Standard coding patterns and quick prototyping
When to use:
- Throughput, cost, or multimodality is the priority
- You want a capable non-OpenAI/Anthropic perspective in the mix
Trade-offs:
- Flash tier — not the deepest reasoner in the family
- Early testers flagged token-efficiency quirks in extended workflows
Pro tip: Flash is genuinely strong for multimodal agent work — screenshots to code, diagram reasoning, video transcript synthesis — where its modality support matters more than raw index rank.
Gemini 3.5 Pro (pending — plan around the uncertainty)
As I write this, Gemini 3.5 Pro is not confirmed shipped. Google reportedly scrapped the original base model over gaps in multi-step math and tool-calling reliability and restarted pretraining on a native Gemini 3 foundation. A July 17 target has been widely reported but not officially confirmed by Google — no model card, no official pricing. Leaks point to a 2M-token context window (twice Opus 4.8’s 1M) and a strengthened Deep Think mode.
Best for (reportedly):
- Whole-codebase reasoning and repository-wide refactoring, if the 2M context holds up
- Long-document and multimodal work at the frontier
When to use:
- Wait for the model card. Until Google publishes one, treat every spec as rumor with strong sourcing
Trade-offs:
- Not reliably available as a public API flagship as of mid-July
- Early testers reportedly found it trailing Fable 5 and GPT-5.6 on coding and long-horizon reasoning
- Launches into a market where GPT-5.6 Sol and Grok 4.5 already shipped (July 9)
Pro tip: Don’t architect around 3.5 Pro yet. Use Gemini 3.1 Pro (preview) or 3.5 Flash today, and re-evaluate once there’s an actual model card and independent benchmarks — which, given the rebuild story, is worth waiting for.
xAI
Grok 4.5 (the value coding play)
Launched July 8, 2026, Grok 4.5 is xAI’s first coding-and-agentic-first model — co-trained with Cursor on real developer session data, built on a 1.5T-parameter foundation. It lands #4 on the Artificial Analysis Intelligence Index (54), tops the index on agentic tool use, and posts strong Terminal-Bench (83.3%) and SWE-Bench Pro (64.7%) numbers — at $2/M input, $6/M output, over 60% cheaper than Opus 4.8 or GPT-5.5.
Best for:
- Agentic, tool-heavy, long-running coding sessions on a budget
- High-volume engineering work where value-per-task matters
- Teams already in Cursor (tight integration)
When to use:
- You want Opus-4.7-class coding at roughly half the per-task cost
- Agentic tool use is the core of your workload
Trade-offs:
- 500K context window — large, but half of Opus/GLM’s 1M
- No published formal system card / safety eval at launch, which matters for regulated environments
- Musk himself framed it as “roughly comparable to Opus 4.7” — very good, not the outright frontier
- One caveat on its Cursor benchmark: an earlier Cursor codebase snapshot was reportedly in training, so treat CursorBench numbers with a pinch of salt
Pro tip: For cost-sensitive agentic coding, Grok 4.5 is one of the best value picks in the market right now. Just do your own eval rather than trusting the co-trained-tool benchmark, and mind the system-card gap if you’re in a regulated shop.
Grok Code Fast (the unlimited-tier workhorse)
Still playing the role it did in January: fast, high-volume, low-stakes coding without eating premium quota.
Best for: boilerplate, quick iterations, high-frequency low-complexity tasks.
When to use: unlimited daily grind work where velocity beats sophistication.
Trade-offs: not for architecture or complex reasoning.
Pro tip: pair it with a frontier model — Grok Code Fast for the volume, something bigger for the hard 10%.
Part 2: The Open-Weight Surge
This is the section that barely existed in January. A year ago open-weight models were for local tinkering; in mid-2026 they’re in real pipelines, and on independent benchmarks the best of them trail the best closed model by single digits, not a chasm. Licenses have also matured — GLM, Kimi, and DeepSeek now ship under MIT; Qwen-Coder and Devstral under Apache 2.0 — so commercial use is genuinely viable.
GLM-5.2 (Z.ai) — the open-weight leader
Currently the strongest open-weight model overall: #1 open on the Artificial Analysis Intelligence Index (51, ~5 points below Fable 5) and top open on SWE-Bench Pro (62.1%), with a 1M-token context window under MIT license.
Best for:
- Long-horizon agentic coding and project-level software engineering
- The open-weight default when you want one model to cover most work
- Teams wanting frontier-adjacent quality without closed-API lock-in
When to use:
- You need self-hostable or non-US-vendor weights with near-frontier coding
- Long-context, multi-step engineering agents
Trade-offs:
- Frontier-tier hardware to self-host (270–400 GB class — think 80GB multi-GPU rigs or an M3 Ultra)
- It “thinks” a lot — output-token consumption can climb (realized ~$0.45/$3.31 per M on hosted routes)
- Not DeepSeek-cheap, though well below closed frontier
Pro tip: GLM-5.2 is the one to test first if you’re evaluating a single open-weight model for serious engineering. Watch the output-token bill on verbose reasoning tasks — its quality is real but so is its token appetite.
DeepSeek V4 (Pro and Flash) — the cost-efficient frontier
DeepSeek V4 comes in a large MIT-licensed Pro (a ~1.6T-param flagship with full 1M context at no premium) and a cheap Flash ($0.14/M input, $0.28/M output, 1M context). Migration note: DeepSeek is retiring the legacy deepseek-chat and deepseek-reasoner API aliases around July 24, 2026 as V4 graduates from preview to stable — if you have anything in production on the old names, calendar that now.
Best for:
- Cost-efficient frontier reasoning (Pro) and cheap high-volume long-context work (Flash)
- Budget-sensitive pipelines that still need a million-token window
- Self-hosted deployments needing permissive licensing
When to use:
- Per-token cost is a hard constraint but you still want strong reasoning
- Long-context tasks at high volume where Flash’s pricing is transformative
Trade-offs:
- Pro is huge — serious self-host footprint
- The July 24 alias retirement is a hard deadline with no announced extension
- Some benchmark leadership claims are vendor-run; verify
Pro tip: DeepSeek V4 Flash is arguably the best cost-per-long-context-token deal in the market. Use it for high-volume RAG, log analysis, or bulk transformation where a 1M window at ~$0.14 input changes the economics entirely.
Kimi K2.6 / K2.7 Code (Moonshot AI) — the multimodal agentic wildcard
An open-weight, native multimodal agentic model (text + image + video), 256K context, MIT-licensed, aimed at long-horizon coding and autonomous execution — with model-card claims of coordinating hundreds of sub-agents across thousands of steps. Its lineage got attention when Cursor’s Composer 2 situation revealed a major tool had deployed an earlier Kimi under a different name — a decent capability signal.
Best for:
- Multimodal agent work: reading screenshots, inspecting UI states, reasoning over diagrams or video
- Long autonomous coding sessions and multi-file editing
- Sub-agent orchestration workflows
When to use:
- Your agent needs to see as well as read
- Long-running autonomous execution is central
Trade-offs:
- The headline sub-agent/autonomy claims deserve careful verification in your own harness before you trust them in production
- K2.7 Code is the newer coding-focused point release; confirm which variant your host serves
Pro tip: Kimi is the open-weight lane to test first when modality is your differentiator. If your agent’s job involves visual state, it’s a stronger fit than text-only rivals with higher raw index scores.
Qwen3-Coder-Next / Qwen3.6 (Alibaba) — the practical local coder
Alibaba plays both ends. Qwen3-Coder-Next is a smaller, efficient MoE (~80B total, ~3B active) under Apache 2.0, built for self-hosted coding agents — the one in this group you can realistically run on a good workstation. Note: Alibaba’s strongest coding model, Qwen3.7-Max, is API-only and closed, so don’t go hunting for weights that aren’t published.
Best for:
- Self-hosted / IDE-integrated coding agents on workstation-class hardware
- Privacy- or residency-constrained coding where the model must stay local
- Apache 2.0 commercial clarity
When to use:
- You want genuinely self-hostable code assistance without a multi-GPU rig
- On a 24–48GB setup where the big MoEs won’t fit
Trade-offs:
- Not the top of any leaderboard — it’s the efficient pick, not the peak
- The best Qwen coder (3.7-Max) is closed, so the open one is a step below the family’s ceiling
Pro tip: Qwen3-Coder-Next punches above its size for local work. On an M4 Max or a 2×48GB pair it’s a legitimate “self-hosted and genuinely good at code” option — the realistic on-ramp to running a coding agent entirely on your own hardware.
MiniMax M3 (Shanghai) — the cheap long-context multimodal
Launched June 1, M3 pairs frontier-ish coding with a 1M-token context and native multimodality via a sparse-attention (MSA) architecture that makes million-token inference far cheaper (428B total / ~23B active MoE). Realized hosted pricing is startlingly low ($0.30/$1.20 per M, rising above 512K context). Independent verification is encouraging — in one third-party bug-hunt test it matched Opus 4.8 at medium effort while costing 18–27× less.
Best for:
- Cheap long-context multimodal agents (screenshots, UI, diagrams, video at 1M context)
- High-throughput workloads where the sparse-attention speed-up matters
- Cost-dominated pipelines that still want multimodality
When to use:
- You need multimodal and long-context and low cost together
- Bulk agentic work where per-run cost is the deciding factor
Trade-offs:
- Many headline benchmarks are vendor-run
- The downloadable weights carry a commercially restricted custom license — read it before you ship (this is the exception to the “open licenses matured” point above)
- Index score dropped from ~55 to ~44 when Artificial Analysis moved to v4.1 — not a regression, a re-weighting, but a reminder not to compare across index versions
Pro tip: M3’s differentiator is modality at long context for near-zero cost, not raw index rank. For high-volume visual-agent work it’s hard to beat on economics — just clear the custom license with whoever owns legal.
Nemotron 3 (NVIDIA) — the reproducible enterprise pick
NVIDIA’s open model line (Super / Ultra tiers), notable less for topping leaderboards (Ultra ~48 on the AA index) than for publishing full weights, training data, recipes, and evaluation resources — with deployment cookbooks for vLLM, SGLang, and TensorRT-LLM.
Best for:
- Auditable, reproducible multi-agent systems
- Regulated or compliance-heavy enterprise deployments where provenance matters
- Teams that need to study and modify the whole system, not just the weights
When to use:
- Reproducibility, auditability, and documented deployment are hard requirements
- You’re standardizing on NVIDIA inference infrastructure
Trade-offs:
- Not the raw-capability leader among open weights
- Larger tiers need serious hardware
Pro tip: If your blocker to adopting open weights is governance rather than capability, Nemotron 3 is the path of least resistance — the documentation and reproducibility story is the product.
Mistral (Large 3 / Small 4 / Medium 3.5) — the European open route
Mistral’s open-weight lineup remains the go-to for multilingual and EU-hosted enterprise work, spanning a capable Large down to an edge-friendly Small.
Best for: multilingual applications, EU data-residency deployments, a tiered open-weight family from one vendor.
When to use: European enterprise contexts, or when you want an open-weight ladder (Small → Medium → Large) under one roof.
Trade-offs: not chasing the top of the global coding leaderboard; positioned on enterprise fit and language coverage.
Pro tip: For EU-regulated deployments, Mistral’s combination of open weights and European provenance often clears procurement hurdles that a US or Chinese model won’t.
Part 3: Beyond Copilot — Where You Actually Run These
January’s guide assumed GitHub Copilot. A growing share of this work now happens elsewhere, so here’s the quick lay of the land.
GitHub Copilot remains the broadest-reach option — the one tool running natively across VS Code, JetBrains, Visual Studio, Xcode, and Eclipse, with an ever-expanding model roster. But two things changed: it paused new Pro/Pro+ signups earlier this year, and it moved to usage-based credit billing on June 1 (Pro’s $10 now buys a monthly credit allowance, not unlimited agent use). If you’re recommending it to a team, the old “unlimited for $10” mental model no longer holds. Still the right default if your team spans multiple IDEs.
Cursor ships its own frontier coding model, Composer 2.5, as the Pro default — reportedly matching Opus-4.7/GPT-5.5-class benchmarks at a fraction of per-token cost ($0.50/M input, $2.50/M output) — alongside third-party model access (Claude, GPT, Gemini, Kimi, Grok). Its edge is deep codebase indexing and IDE-native parallel agents. It’s become the default pick for many now that Copilot paused signups.
Codex (OpenAI) is the home turf for GPT-5.3-Codex and the GPT-5.6 family — CLI, IDE extension, cloud, and code review, oriented around agentic, long-running tasks.
Windsurf → Devin Desktop: Cognition rebranded Windsurf to Devin Desktop in June, bundling the Devin Cloud agent and a terminal CLI and adopting the open Agent Client Protocol. It leans toward a delegated agent that opens PRs on your behalf, versus Cursor’s in-editor pair-programmer model.
Claude Code remains the pick for deep, multi-file agentic work driven by Anthropic’s models directly.
None of these are mutually exclusive. The pattern I see working is a layered stack: a broad-reach inline tool (Copilot) for daily autocomplete, a purpose-built agentic IDE (Cursor / Claude Code / Devin) for heavy multi-file work, and a direct API or open-weight route for high-volume, cost-sensitive pipelines.
Part 4: Matching Model to Task — The Mid-2026 Framework
The core advice hasn’t changed — match model to task — but the menu has. Here’s the updated routing table:
| Task | Reach for |
|---|---|
| Everyday coding / default | Claude Sonnet 5, GPT-5.6 Terra, Gemini 3.5 Flash |
| Long-horizon, architecturally hard | Claude Opus 4.8, GPT-5.6 Sol, GPT-5.3-Codex |
| Highest-stakes / mission-critical | Claude Fable 5 (sparingly) |
| Fast, high-volume, low-complexity | Claude Haiku 4.5, GPT-5.6 Luna, Grok Code Fast |
| Cost-sensitive agentic coding | Grok 4.5, DeepSeek V4 Flash |
| Self-hosted / data-residency | GLM-5.2, DeepSeek V4 Pro, Qwen3-Coder-Next |
| Multimodal / visual agents | Kimi K2.6/K2.7, MiniMax M3, Gemini 3.5 Flash |
| Cheap long-context bulk work | DeepSeek V4 Flash, MiniMax M3 |
| Reproducible / audited enterprise | Nemotron 3, Mistral (EU) |
A scenario playbook
Building a new REST API: architecture with Opus 4.8 or Sol → scaffolding on Haiku 4.5 or Grok Code Fast → business logic on Sonnet 5 or GPT-5.3-Codex → security review on Opus 4.8 → tests on Haiku/Luna → docs on Sonnet 5.
Debugging a production issue: stack-trace triage on Luna or Haiku → root-cause on Sonnet 5, escalating to Opus 4.8 or Sol if it’s genuinely deep → fix and verify on Sonnet 5.
High-volume feature grind on a budget: boilerplate on Grok Code Fast or DeepSeek V4 Flash → standard implementations on Grok 4.5 → the hard 10% on Opus 4.8 or Sol → review on Sonnet 5.
Self-hosted / air-gapped coding agent: GLM-5.2 if you have the hardware and want peak open-weight quality; Qwen3-Coder-Next if you’re on workstation-class hardware; Nemotron 3 if governance and auditability are the real constraints.
Multimodal agent (reads UI, diagrams, video): MiniMax M3 for cheap long-context multimodality, Kimi K2.6/K2.7 for autonomous multimodal execution, Gemini 3.5 Flash for a closed-source option.
Conclusion
Six months in this industry is a full model generation, sometimes two. January’s specific model names are mostly retired, but the discipline that post argued for — understand the trade-offs, don’t default to whatever’s newest — matters more now, not less, because the field widened from “four labs shipping GPT and Claude variants” to “four closed labs plus a genuinely competitive open-weight ecosystem, reachable from half a dozen different IDEs.”
The single highest-leverage habit is building fluency across a small portfolio rather than marrying one model: one closed-frontier default (Sonnet 5 or Terra), one cost-efficient workhorse (Grok 4.5, DeepSeek V4 Flash), and increasingly one open-weight option you can self-host (GLM-5.2 or Qwen3-Coder-Next). Then switch deliberately based on what the task actually needs.
Your next steps:
- Re-evaluate your default. If you’ve been on the same model since January, the cost/capability curves have moved under you — Sonnet 5 and the GPT-5.6 tiers alone change the math.
- Pressure-test one open-weight model (GLM-5.2 or DeepSeek V4 are the easiest on-ramps) against your current default on a real task, not a toy benchmark.
- Check the deadlines: DeepSeek’s July 24 API-alias retirement, and Copilot’s June billing change if your cost model still assumes “unlimited.”
- Watch Gemini 3.5 Pro and DeepSeek V4 stable — both land within days of each other. Wait for model cards and independent benchmarks before committing.
- Above all: benchmark on your own codebase. Every number in this post is a shortlist signal, not a decision.
Till next time, Happy Coding and Keep AI Learning!