How I Decide When I Should Use Claude or GPT or Something Else...

Technological concepts & model-selection framework

• The speaker maintains a running “what to use when” guide for LLMs, motivated by how quickly model ecosystems change. Their current view is as of Aug 5, 2026.

• They use a 2-axis mental model for choosing between models:

  1. Prompt specificity (vague → very specified) How detailed the instructions need to be to reliably get the desired output.

  2. Brute force vs “beautiful code that scales”

     • Brute force: acceptable if the model just solves the problem for personal testing/analysis; code quality and production readiness don’t matter.
     • Beautiful/scalable code: needed when code ships to end users; it should be robust, maintainable, and not painful to merge.

---

Model-by-model opinions, roles, and feature notes

GPT (“GPT 5.6 Sol / Codex / 5-6”)

• Strong for general-purpose, agentic tasks and “computer use,” especially when the task horizon is shorter.
• The speaker notes that others find it too literal and sometimes produce code that is not as good as Claude’s—but they personally use it heavily due to efficiency and usefulness.
• Example use:
  • Spinning up workflows on local/spark setups by providing a URL + repos, then letting the agent execute and integrate results into configuration automatically.

Claude (“Claude / Claude Code / Fable 5 / Opus” family)

• In the speaker’s view, the only Claude model currently worth using is “Fable.”
• Fable 5 is their preferred model for long-horizon coding where output quality matters most (“beautiful code that scales”).
• They dislike Opus more than before and believe others disliked it too (they reference a separate dedicated video).

Open-weight models: DeepSeek V4 Flash + “Luna”

DeepSeek V4 Flash (checkpoint mentioned: ~0731 / “V4 Flash”)

• Absurdly cheap and very fast.
• Roughly on par with Opus-class performance (“punches above its weight”).
• Key operational point:
  • Because it’s open-weight, it has fewer/looser safety safeguards than frontier hosted APIs.
  • The speaker claims it can follow highly disallowed instructions more readily (e.g., “try to hack my site to find security vulnerabilities”).

Luna

• Speaker claims paper performance is better than DeepSeek V4 Flash, but in practice they use both.
• Tradeoff:
  • Frontier-style safeguards still apply more to Luna than to the open-weight DeepSeek V4 Flash.
• In the framework:
  • Both are leaned toward brute-force unless heavily guided with examples/direction.
  • The speaker says open-weight models don’t “write amazing code out of the box” and need better prompting/constraints to reach “beautiful” quality.

xAI Grok 4.5

• Surprised them: fast and cheap, good to try.
• Suggested integration paths:
  • Cursor, or Grok’s build CLI
• They praise one CLI experience:
  • Cursor background agent / Grok build CLI as especially impressive.

“Opus 5”

• Mentioned as a reference point, but the speaker says they haven’t used it much because it “fell over” after early promise.

---

“Distance” / agent-run intuition (why Claude vs GPT feels different)

• The speaker conceptualizes agentic work as a journey on a map:

  • Models can be blocked by guardrails (lint rules, check commands, harness guardrails) that act like walls preventing veering off course.
  • The hard part is specifying the true target state in natural language.

• Key distinction:

  • Fable: better at correctly interpreting where the target “is,” maintaining the right trajectory over longer time horizons.
  • GPT 5.6: good at reaching a working destination, but may become too complex/disorganized or suffer subtle misinterpretations—especially when allowed to run for hours.
• Over short horizons, the speaker claims many models are more reliable; “full distance” failures are primarily a long-horizon problem.

---

Harnesses / tools they use day-to-day (interfaces + orchestration)

Primary model-control surfaces

• Codex
  • CLI + desktop app (Claude desktop app is said to be not good).
• Claude Code
  • CLI
• They also mention using Cursor more, especially background agent features.

Pi (agent orchestrator)

• The speaker describes Pi as an agent that orchestrates other agents.
• Their custom Pi setup adds sub-agent support for both Codex and Claude Code.
• Orchestration strategy:
  • Use Fable to plan/review/implement while letting Pi manage the multi-agent workflow.
  • This helps manage weaker/less convenient models (e.g., letting Fable handle Opus 5 rather than using Opus directly).

Additional interface

• T3 Code

  • Praised as the best remote experience.
  • Runs via a web URL tied to a Tailscale endpoint into a Linux home server.
  • Allows prompts to be sent remotely and lets the laptop shut down while agents run.

• They allude to sub-agent execution/verification loops using:

  • Harness checks
  • Lint rules
  • Guardrails

---

Usage metrics & subscription notes

Rough usage breakdown (by tokens)

• ~2B tokens on 5-6 Sol
• ~600M tokens on Fable
• ~100M tokens on Opus
• ~100M tokens on DeepSeek

Subscription strategy

• Two Claude Max plans due to Fable’s “brutal” limits (the speaker says they burn through one quickly during heavy weeks).
• One Codex sub because it’s generous and efficient enough.

Vi Proxy

• Vi Proxy is an open-source tool they self-host on Linux.
• Purpose:
  • Load balances between two Claude subs to avoid constant logouts.
• Constraint they mention:
  • They use it only to split between Claude Code accounts—not to route Claude usage into other harnesses.
  • They believe routing across harnesses may trigger ToS bans.

---

Sponsor segment: “Encore” (infrastructure-as-code platform)

• Encore is promoted as an infrastructure-as-code platform:

  • Easy to use with TypeScript-defined infrastructure (contrasted with “giant hellish Terraform files”).
  • Works as orchestration for AWS and GCP directly (not locked into a “baby cloud” abstraction).
  • Integrates well with agents because everything is infrastructure-as-code.

• Example built by the agent:

  • A dependency radar app using Encore + SvelteKit
  • Features:
    • Sync top npm packages every 30 minutes
    • Store in Postgres
    • Use Encore APIs
    • Cron jobs and pub/sub
    • Searchable UI
    • Per-package pages
    • Local app execution
    • Possible object storage (not required in that example)

• Positioning:

  • Encore is framed as a good agent playground—agents can generate and deploy a functioning app with backend services like compute, DB, scheduling, and messaging.

---

Content add-ons / guide references

• The speaker references prior/published resources:
  • Dedicated videos for GPT 5.6 and Claude Fable 5
  • A dedicated video on why Opus soured
  • A companion Substack article with more detail on “harnesses and models used”
• They also announce a paywalled Substack for more “unfiltered thoughts”:
  • Videos won’t be paywalled; Substack is supplemental.
  • They plan “spicier” posts on open-weight/local models (noting it’s politically charged).

---

Main speakers / sources (as stated)

• Primary speaker/source: the video’s sole narrator (no named co-speakers in the subtitles).
• Sponsored source mentioned: Encore (via a sponsor segment).
• Model providers referenced:
  • OpenAI (GPT/Codex)
  • Anthropic (Claude/Fable/Opus)
  • DeepSeek
  • xAI (Grok)
• Additional tools/harnesses/infra mentioned:
  • local/DGX setup
  • Tailscale / Vi Proxy / T3 Code / Cursor / Pi / Codex CLI / Claude Code CLI