AI models

The families, the tiers, and how to pick without chasing leaderboards.

Underneath every tool in this guide is a model: a large language model (LLM) trained on a huge share of the world's text and code. The model is the brain; the tool you type into is the body around it. Get a few ideas about models straight and you can skip the endless online discourse entirely.

Labs ship families, not models

Each frontier lab releases a whole family with tiers, never one single model. There's always a fast, cheap tier for everyday work and a heavyweight tier for genuinely hard problems:

The practical rule: run the everyday tier by default, and escalate to the heavyweight only when something is genuinely hard, like a stubborn bug, a big refactor, or an architecture decision. Heavyweight models cost several times more per request, so for routine edits they're overkill. (Inside a coding agent you often don't pick at all: Codex quietly runs a coding-tuned GPT-5-Codex model, and the agents choose sensible defaults for you.)

The same model can think harder

On top of the tiers, most models now take a reasoning effort setting that controls how long they think before answering. GPT-5.5, for example, runs from low up through high and xhigh. In Codex you set it with the /effort command (Claude has an equivalent); higher settings mean better answers on hard problems at the cost of more time and more tokens. Dial it up for a thorny bug, back down for routine work. It's the same instinct as reaching for a heavier model, just without leaving the one you're already in.

One smart model, cheaper hands

As you get comfortable, one pattern pays off again and again: stop asking a single model to do everything, and run a small team instead. Put your most capable model in the orchestrator (or planner) seat, where its judgment is worth paying for. It reads the problem, writes the plan, and hands the actual typing to cheaper, faster models. The smart one thinks and reviews; the cheap ones do the bulk of the work.

The pairing is yours to choose and completely model-agnostic: a heavyweight planning while a mid-tier executes, a high-effort model directing a lighter one, whatever your tools support. The savings are large because the expensive reasoning only happens where it matters. Published breakdowns of these mixed setups routinely land 60 to 70 percent cheaper than running the top model for every keystroke, with output that's nearly as good, because the hard thinking still happened up top.

• –You may already be doing it. Claude Code's plan mode plus subagents is a soft version of this: the main model plans, its helpers run on lighter models. Plugins push it further with explicit model-tier routing.
• –Cache what repeats. Prompt caching reuses a big chunk of unchanging context (your project rules, a large file) instead of paying to resend it every single turn.
• –Set a hard spend cap. A capable model in a long loop can run up a bill fast, so cap it in your provider's billing settings before you point it at anything that runs unattended.

One honest caveat: orchestration has overhead, since routing a job through a planner adds tokens at every hop. For a quick one-shot task, just asking a cheap model directly beats convening a committee. The crew earns its keep on big, parallel, or long-running work, not on quick edits.

Beyond the big labs

The closed labs above aren't the whole map. A wave of open-weight models, ones you can download, run locally, or rent cheaply, has caught up fast on coding: DeepSeek and Qwen (permissively licensed and inexpensive), Kimi (tuned specifically for long agentic coding loops), and GLM. You don't need these on day one, but it's worth knowing the frontier isn't only rented from three companies. If you ever want to keep code entirely on your own machine, this is the branch you'll explore.

Taste comes from use

Here's the part no benchmark captures: the more you use these models, the more you develop a feel for what each one is good at. A genuinely useful habit is to take one prompt and run it across two or three models, then keep the output you like best. Do that enough and patterns emerge, like Gemini's clean visual defaults, Claude's strength in a back-and-forth, one model's knack for gnarly logic. Switching is only ever a dropdown (or a /model command), so you're never locked in and there's no decision to agonize over.

A note on Fable 5

One model earns a footnote. In mid-2026 Anthropic released Claude Fable 5, currently the strongest coding model anyone has shipped, a tier above Opus and topping the hardest benchmarks (Stripe used it to run a migration across a 50-million-line codebase in a day). It's also hungry, at roughly twice Opus and ten times Haiku on output tokens. So think of it less as your daily driver and more as the obvious pick for that orchestrator seat, or for a genuinely hard one-off, while cheaper models carry the routine work.

AI Clubhouse · Vibe Coding Guide