I Finally Get Fable 5
🔗 **Source:** [I Finally Get Fable 5](https://www.youtube.com/watch?v=8GRmLR__OGQ)
> [!note]+ Document Notes
> tags: [ai-coding-agents, claude-code, model-routing, agentic-workflows, developer-productivity]
> author: Theo (t3.gg)
> source: YouTube — Theo (t3.gg)
> reference: https://www.youtube.com/watch?v=8GRmLR__OGQ
> date created: {{date:YYYY-MM-DD}} {{time:HH:mm}}
>
> # 🏷️ Title: I finally get Fable 5
>
<!-- deep-read:sections start -->
## 🧭 Table of Contents
- [📝 Summary](#-summary)
- [📖 Main Content](#-main-content)
- [🗒️ Notes](#️-notes)
- [📚 References](#-references)
- [🗣️ Paraphrase](#️-paraphrase)
- [📰 Newsletter](#-newsletter)
- [✅ Action Items](#-action-items)
- [🧪 Hypotheses](#-hypotheses)
- [📊 Methodology](#-methodology)
- [❓ Questions](#-questions)
- [🔮 Future Research](#-future-research)
- [💡 Implications](#-implications)
- [🧠 Learning Styles Assessment](#-learning-styles-assessment)
- [📊 Accessibility Assessment](#-accessibility-assessment)
- [🌍 DEIB Assessment](#-deib-assessment)
- [✅ Logical Validity](#-logical-validity)
- [🛡️ DARVO Analysis](#-darvo-analysis)
- [🎯 Conclusion](#-conclusion)
### 🔗 References
- [Video: I finally get Fable 5](https://www.youtube.com/watch?v=8GRmLR__OGQ)
- [Theo's companion "misconceptions" tweet/source](https://x.com/theo/status/2072898342921842703)
- [Clerk (sponsor)](https://soydev.link/clerk)
- [Infinite Red (sponsor)](https://soydev.link/infinite)
- [t3.gg](https://t3.gg)
## 📝 Summary
- Theo (t3.gg) walks through how he actually works with Anthropic's Fable 5 model inside Claude Code, arguing it's not "a better Opus" but a categorical shift in how far an agent can run end-to-end.
- Why it matters: the value isn't raw intelligence, it's autonomy across implementation, testing, verification, sub-agents, and multi-agent workflows. Reusing old Opus-era prompts wastes the model.
- Key stakeholders: solo/lead developers on agentic Claude Code workflows, teams weighing model-routing costs, and anyone building on the T3 stack (Lakebed, T3 Code).
- Risks and tradeoffs: cost blowups from wrong reasoning settings, over-reasoning on X-high/Max, blind-merging agent code, and staging environments getting polluted by unsupervised agents.
- Bottom line: keep reasoning on high, route expensive token work to cheaper models (GPT-5.5 via Codex CLR), let Fable orchestrate, gate production behind a human, and verify hard. He shipped a month of backlog in ~3 days for ~$150.
## 📖 Main Content
- Core claim: Fable 5 changes what's possible not by being smarter per step, but by running much *further* — end-to-end implementation, testing, verifying, and decomposing tasks to sub-agents. Old Opus prompts underuse it.
- Cost discipline comes first. Theo deliberately front-loads "min-maxing" so viewers don't bankrupt themselves adopting the workflow. His full 5.5-hour run cost ~$150 across all models, with neither subscription (Claude Code + Codex) breaking 40% weekly usage.
- Reasoning-effort thesis (contested/opinion): stay on low–high; X-high, Max, and "Ultra Code" over-reason, produce bloated changes, and cost far more. He claims reasoning effort applies *per tool call / per step*, not to how long the agent can run — so Max thinks more per step, not more steps. He notes Ultra Code uses "high" under the hood.
- Model routing: he teaches Claude Code (Fable) to "shell out" to GPT-5.5 via the Codex CLI for token-heavy or computer-use work (log digging, giant PDFs, screenshots, browser/simulator automation), because Codex's usage allotment is very generous and its computer use beats Anthropic's right now.
- He encodes a personal model rubric in his global claude.md — scoring cost, intelligence, and taste (1–10) for GPT-5.5, Sonnet 5, Opus 48, and Fable — plus a glossary defining "intelligence" (hardest problem handled unsupervised) and "taste" (UI/UX, code quality, API design, copy). Defaults are framed as overridable: "judge the output, not the price tag."
- Sub-agents vs workflows: sub-agents spawn parallel agents; workflows are programmatic JS scripts that fan out, stage, and verify deterministically. Fable now invents review archetypes (adversarial, exploratory) itself, making hand-built agent taxonomies obsolete.
- The showcase: a simple prompt ("investigate and review the open PRs for Lakebed") spawned a workflow, 48 agents (16 investigators + a Fable/Opus judge panel), and produced a triage. He then set a "goal" granting merge/rebase/worktree permissions; it ran ~5 hours and landed a month of backlog.
- Safety framing: merging straight to main is only safe because merges deploy to *staging*, production stays human-gated, and he stress-tested afterward with more agents — burning more tokens verifying than producing. Uncertainties: he's candid the reasoning-effort and over-reasoning claims are his gut feel, and that some agent outputs were wrong (the phantom "drawer").
### 🗒️ Notes
*Timestamps below are estimated from transcript position — the source captions carried no time anchors, so treat them as approximate jump points.*
#### ⏱️ [00:00](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=0s) Cold open: Fable one-shot me
- Says Fable "one-shot" him; loved it more each day, then lost access and struggled with Opus 48 and GPT-5.5.
- On its return: "It's better than I remembered." First day back, more work done than the prior month.
- Thesis lands: "this model isn't a better opus."
#### ⏱️ [02:11](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=131s) Watch the misconceptions video first
- Points to a companion video answering "nerfed / too expensive" complaints from Twitter before this one.
#### ⏱️ [02:46](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=166s) What this video covers: the how, not just the what
- Focus is the prompts, systems, claude.md changes, and skills — plus the mindset shift. "Fable isn't just an improvement."
#### ⏱️ [03:37](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=217s) Sponsor: Clerk (auth + billing)
- Auth and billing are agent "kryptonite"; Clerk attaches payment to the user, mirrors staging/prod without Stripe key duplication.
#### ⏱️ [06:07](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=367s) A month of Lakebed PRs shipped in 2-3 days
- Shows ~11-12 PRs merged from one thread; he's still Lakebed's only contributor. Had 20-30 stale PRs at 50-80% done that he didn't trust.
#### ⏱️ [08:30](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=510s) Min-maxing: cost reduction before the workflow
- Deliberately teaches cost control first; the full run's true cost would've been thousands but was ~$150 across all models.
#### ⏱️ [09:45](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=585s) Never push reasoning past high
- "Do not use Fable on higherthan high reasoning efforts." X-high/Max/Ultra Code over-reason and overspend.
- "High is way smarter." Claim: reasoning effort is per step, not run length; Max thinks more per step, not more steps.
- Ultra Code uses "high" under the hood.
#### ⏱️ [12:51](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=771s) Teaching Claude Code to call Codex
- Route token-heavy and computer-use tasks to GPT-5.5 via the Codex CLI; OpenAI's computer use "slaughters" Anthropic's right now.
#### ⏱️ [14:38](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=878s) Usage stayed under 40% for the week
- ~1 hour of setup; Codex sub at ~15%, Claude Code sub at 40% at hardest push. Codex allotment ≈ "$14 grand of inference a month."
#### ⏱️ [16:03](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=963s) Global claude.md: shell out to GPT-5.5
- Key line in claude.md: if computer use helps complete/verify work, "shell out to GPT55 with codecs." The word "shell out" tells the model it can call GPT-5.5 via bash.
#### ⏱️ [17:30](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1050s) Sub agents vs workflows
- Sub-agents = parallel spawned agents; workflows = programmatic JS staging that fans out and verifies. Used a workflow to triage stale PRs.
- Fable invents review archetypes itself, killing hand-built agent taxonomies.
#### ⏱️ [19:39](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1179s) Ranking models: cost, intelligence, taste
- Model's self-awareness of its own capabilities is weak (trained before 5.5 / Opus 48). So he supplies the gut-feel routing.
- GPT-5.5: cost cheap, intelligence high, taste low ("writes TypeScript like a Python dev, Rust like a paranoid C++ dev").
#### ⏱️ [21:03](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1263s) claude.md as a glossary of your terms
- Biggest claude.md win is a glossary: define "intelligence" (hardest unsupervised problem) and "taste" (UI/UX, code quality, API design, copy).
#### ⏱️ [21:56](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1316s) Defaults, not limits: escalate freely
- The model wrote a "defaults not limits" rule granting standing permission to rerun with a smarter model. "Judge theoutput, not the price tag."
- Live-edits the model's own line about cost precedence to match his view.
#### ⏱️ [23:13](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1393s) Never use haiku; routing 5.5 inside workflows
- "Neveruse haiku" — not useful when 5.5 is effectively free. GPT-5.5 only reachable via Codex CLI; inside workflows, use Sonnet on low to spawn 5.5 and report back, with a prefix so he can spot which sub-agents used it.
#### ⏱️ [24:59](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1499s) Skills: Codex review, implementation, computer use
- Three lean skills: Codex review (independent second pass), Codex implementation (bounded worktree work), and computer use (5.5 runs local verification, screenshots, simulators).
- Skill descriptions must carry enough info for the model to decide whether to call it; prompt Codex simply, not "like Claude."
#### ⏱️ [30:36](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1836s) The prompt: investigate the open PRs
- 16 open PRs of half-finished work. Prompt asks for a categorized list (ready / needs rebase / trumped / good-idea-but-rewrite) and "use a workflow to break up the work into multiple reviewers."
#### ⏱️ [32:18](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1938s) Triage from 48 agents, judged by a panel
- "All 48 agents finished. 16 investigators, one per PR." Each verdict stress-tested by a Fable + Opus judge panel; 14/16 unanimous.
#### ⏱️ [33:15](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=1995s) Spec and prioritize the surviving PRs
- Second goal: close trumped PRs, then write HTML plans (via his planning skill) honoring Lakebed's simplicity, with links back to inspiring PRs. Read on his phone.
#### ⏱️ [34:36](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2076s) Streams of work, not one giant workflow
- Asks whether to use one workflow or hand-made worktrees. Model answers "neither": workflows are deterministic scripts for fan-out/verify, but a checkpoint-driven program (CI, review, merge, product calls) needs session orchestration + worktrees, workflows only for review passes. It also found parallelism between plans.
#### ⏱️ [37:56](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2276s) The goal: keep going until conditions pass
- A "goal" loops until conditions pass. "You have permission to create worktrees, rebase, branch, merge PRs, closePRs, etc." Gate: no merge until Bugbot, Macroscope, and Code Rabbit approve.
#### ⏱️ [38:14](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2294s) Sponsor: Infinite Red (mobile)
- Mobile is where AI struggles; Infinite Red modernizes codebases and preps teams (Expo/React Native, Swift/Kotlin bindings).
#### ⏱️ [40:32](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2432s) Ran 5 hours; a month of work landed
- Goal ran ~5 hours; every GitHub check on his phone showed more code landed. A month's roadmap now in Lakebed.
#### ⏱️ [41:19](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2479s) Human-in-the-loop: staging vs prod
- Merging to main only deploys staging; "the model cannot ship or touch prod." He first had Fable repair a staging environment other models had broken.
#### ⏱️ [42:46](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2566s) Verifying cost more tokens than doing
- Stress-tested with more agents on main vs prod diffs. "I burned way more tokens trying to verify the work that Fable did here than I burned getting Fable to do the work here." Nothing needed changing — reads it as not pushing hard enough.
#### ⏱️ [44:10](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2650s) T3 Code over SSH and Tailscale
- Claude over raw SSH loses image paste, select, scroll. T3 Code + Tailscale drives agents on other machines from phone or desktop. All open source; he's spent ~$250k on it, "This is a gift."
#### ⏱️ [46:01](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2761s) Parallelizing work across machines
- Spins up worktrees per bug from his phone; merges several experimental worktrees into one branch with conflicts handled. Doesn't expect most of this throwaway code to ship.
#### ⏱️ [50:53](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=3053s) Time-to-fix signals codebase health
- Under 3 min = simple fix, merge it; 15 min = pay attention; over an hour = architecture problem. A phantom "drawer" fix that landed in 2m20s concerned him because it was suspiciously simple and partly wrong.
#### ⏱️ [53:45](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=3225s) Pro tip: VibeProxy for limits
- VibeProxy auto-splits traffic across accounts (API-key Claude Code, so you lose /remote and a few features).
#### ⏱️ [55:01](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=3301s) Outro
- Thought the video would be short. "I'm going to go back to coding. I hope this inspires you to do the same." "So until next time, peace nerds."
## 📚 References
- [I finally get Fable 5 — YouTube](https://www.youtube.com/watch?v=8GRmLR__OGQ)
- [Theo status (misconceptions source)](https://x.com/theo/status/2072898342921842703)
- [Clerk](https://soydev.link/clerk)
- [Infinite Red](https://soydev.link/infinite)
- [t3.gg](https://t3.gg)
## 🗣️ Paraphrase
- Fable 5 impressed Theo, and after losing then regaining access he rates it above his memory of it; the real leap is how far it runs autonomously, not per-step intelligence.
- Treating it like Opus wastes it; the win is end-to-end implementation, testing, verification, and clean sub-agent decomposition.
- He front-loads cost control: keep reasoning on high (X-high/Max/Ultra over-reason and overspend), and route token-heavy or computer-use work to GPT-5.5 through the Codex CLI.
- His global claude.md encodes a cost/intelligence/taste rubric plus a glossary, framing model choices as overridable defaults ("judge the output, not the price tag").
- The centerpiece is a PR-triage-to-merge run: one prompt spawned a 48-agent workflow with a judge panel, then a permissioned "goal" ran ~5 hours and shipped a month of backlog for ~$150.
- Safety rests on staging-only merges with prod human-gated, plus heavy post-hoc verification that cost more tokens than the original work.
## 📰 Newsletter
- If your Claude Code sessions feel like an expensive Opus, this walkthrough is the mindset reset: let the newer model *orchestrate*, don't just prompt it harder.
- Practical wins you can steal today: pin reasoning effort to "high," add a glossary to your global claude.md (define what *you* mean by "intelligence" and "taste"), and give the model standing permission to escalate to a smarter model when output misses the bar.
- The routing trick — "shell out" to a cheaper CLI model for log-digging, giant PDFs, and computer-use — is directly transferable to WordPress agent workflows where screenshot-heavy QA burns tokens.
- Governance takeaway for anyone letting agents merge: keep merges on *staging*, human-gate production, and budget real tokens for verification. The maker/checker split is the whole safety story here.
## ✅ Action Items
#### DevRel
- Developer advocacy: draft a short demo showing "high vs X-high" reasoning cost deltas on a real repo to test the over-reasoning claim publicly.
- Education: build a workshop module on model-routing (orchestrator + cheap executor) and the "goal until conditions pass" loop pattern.
- Developer experience: publish a claude.md glossary template (intelligence/taste definitions + escalation rule) as a copyable quickstart.
- Developer marketing: content series on "cost min-maxing agentic runs" with attribution to measurable token savings.
- Community management: gather community reproductions of the reasoning-effort claim to separate opinion from measured fact.
- Internal/external/cross-project: align a shared verification-token budget norm for agent-merged PRs.
#### OSPO
- Policy & Governance: define contribution policy for agent-authored PRs (staging-only merge, human prod gate, required reviewers).
- License Compliance: confirm any pasted/adapted skill snippets carry compatible licensing before internal reuse.
- Security Management: threat-model an agent with merge + worktree permissions; scope credentials to staging.
- Software Inventory: track which models/CLIs a workflow invokes (SBOM-style manifest of Fable/GPT-5.5/Sonnet routing).
- Developer Support: office hours on setting up Codex-CLI routing safely.
- Community Engagement: coordinate with tool maintainers (Codex, Claude Code) on workflow reliability gaps.
- Strategic Alignment: KPI for cost-per-shipped-PR when routing cheap executors under a smart orchestrator.
#### Community
- Maintainers: publish a PR-triage workflow template (investigate → categorize → judge panel → suggested merge order).
- Contributors: "first issue" rotation for building lean skills (review, implementation, computer-use).
- Sponsors: transparent token-budget reporting for agent-heavy contribution drives.
- Ecosystem: shared incident drill for agents polluting staging environments.
#### WordPress
- Core: evaluate reasoning-effort defaults when agents touch core patches; require human gate for trunk.
- Core Performance: profile token cost of screenshot-heavy QA vs routing to a cheaper computer-use model.
- Core AI: responsible-AI guardrail — agents may merge to staging only; production stays human-approved.
- **Core Program Team:** define cross-team ritual for reviewing agent-authored changes with automated reviewers before merge.
- Mobile: note Theo's point that AI struggles on native mobile; keep human review dense there.
- Playground: reproducible lab showing the orchestrator-plus-cheap-executor pattern in-browser.
- Community: meetup kit on safe agent permissions (staging vs prod).
- Training: lesson on writing skill descriptions that trigger correctly (description carries the decision info).
- Marketing: narrative on "shipping a backlog" responsibly, not blindly.
- Support: knowledge-base entry on transient CI failures with agent reruns.
- Design: capture "taste" as reviewable criteria (UI/UX, API design, copy) in design QA.
- Documentation: split user docs from maintainer docs (Theo's "hard cut" example).
- Photos: not applicable to this source — no media asset workflow discussed.
- TV: caption-quality note — this transcript had no time anchors; flag as a captioning gap.
- Polyglots: not applicable to this source — no localization content.
- Accessibility: audit agent-generated UI changes against WCAG before merge.
- Meta: track API/CLI reliability (cursor adapter transient failures cited).
- CLI: document safe wp-cli-equivalent guardrails for agent shell-out patterns.
- Hosting: cross-host checklist for staging isolation so agents can't reach prod.
- Tide: false-positive review loop analogous to "if Codex finds nothing, say so clearly."
- Openverse: not applicable to this source — no media ingestion content.
- Themes: review throughput gains possible via multi-reviewer workflows.
- Plugins: security liaison review required for any agent-merged plugin code.
#### The WPCC
- Programs: fellowship track on agentic workflow engineering and cost governance.
- Projects: documentation sprint turning this workflow into a reusable governance clinic.
- Funding experiments: milestone payouts tied to verified (not just merged) agent output.
### FAIR
- Technical independence: keep routing/rubric metadata local and provenance-tracked, not vendor-locked.
- Policies and covenants: transparency on model deals (Theo clarifies he has no special OpenAI deal — the model hallucinated one).
- Productized governance artifacts: a scorecard for "agent may merge here" permissions by environment.
## 🧪 Hypotheses
- H1: On agentic coding tasks, "high" reasoning effort yields equal-or-better task success at materially lower token cost than X-high/Max.
- H2: Routing token-heavy and computer-use subtasks to a cheaper CLI model (GPT-5.5 via Codex) reduces total run cost by >5x versus running everything on Fable.
- H3: Adding an explicit intelligence/taste glossary to claude.md improves model routing decisions versus no glossary.
- H4: A judge-panel workflow over per-PR investigators produces higher-agreement triage verdicts than single-agent review.
- H5: Time-to-fix correlates inversely with local codebase health (fast fixes = simple areas; long fixes = architectural debt).
- H6: Post-merge multi-agent verification catches materially fewer defects when the producing model is Fable than when it's Opus/GPT-5.5 (i.e., verification "finds nothing").
### 📊 Methodology
- Controlled A/B runs on a fixed task suite comparing reasoning-effort levels, logging tokens, wall-clock, diff size, and pass/fail.
- Cost instrumentation across model routes (Fable-only vs orchestrated) on identical PR-triage tasks.
- Randomized presence/absence of a claude.md glossary; measure routing correctness against a human-labeled gold set.
- Inter-rater agreement analysis on judge-panel vs single-reviewer verdicts.
- Regression of fix duration against independent codebase-complexity metrics (churn, cyclomatic complexity, coupling).
### ❓ Questions
- Is the "reasoning effort is per step, not per run" claim architecturally accurate, or an approximation of observed behavior?
- How much of the ~$150 figure depends on Codex's temporarily generous allotment, and how does it change once that normalizes?
- What defect rate slips through when agents merge to staging unsupervised over long runs?
- Does "invent your own review archetypes" beat curated adversarial/exploratory sub-agents on measurable review quality?
### 🔮 Future Research
- Benchmarks isolating "how far a model runs" (autonomy horizon) from per-step intelligence.
- Standardized cost accounting for multi-model orchestration in coding agents.
- Guardrail patterns that let agents merge safely while provably never reaching production.
- Empirical validation of time-to-fix as a codebase-health signal.
### 💡 Implications
- Practice: the leverage shifts from prompt-craft to orchestration design, routing rubrics, and verification budgets.
- Policy: environment-scoped merge permissions and human production gates become table stakes for agent autonomy.
- Security: an agent with worktree/merge rights is a real attack surface; scope credentials to staging.
- Education: teaching "how to influence your agents" (claude.md, skills, glossaries) matters as much as teaching code.
- Funding models: paying for verified output, not merged output, aligns incentives with quality.
### 🧠 Learning Styles Assessment
- Reading level estimate: Flesch-Kincaid Grade ~7-8 (conversational, contraction-heavy monologue; short clauses, some jargon like "worktree," "sub-agent," "reasoning effort").
#### 👀 Visual learners
- Present: on-screen GitHub PR lists, claude.md/skill files, and workflow code shown during narration.
- Improve: a routing-decision diagram (task type → model) and a before/after backlog burndown would help.
#### 🔊 Aural learners
- Present: full spoken narration (this is a talking-head walkthrough).
- Improve: a 2-5 minute audio recap of the cost + routing rules.
#### 🗣️ Verbal learners
- Present: explicit definitions of intelligence and taste; analogy of the reasoning slider as a slot machine.
- Improve: a glossary card for worktree, workflow, sub-agent, goal, skill.
#### 🧩 Kinesthetic learners
- Present: step-by-step "here's the prompt, here's the goal" reproduction.
- Improve: a copyable checklist to set up Codex routing and a staging-only merge gate.
#### 🧠 Logical learners
- Present: the cost/intelligence/taste scoring table and merge-order reasoning.
- Improve: a decision tree for when to escalate models and a time-to-fix → action mapping.
#### 🧑🤝🧑 Social learners
- Present: direct address, invites feedback ("let me know what you think of my workflow").
- Improve: a community repo of shared skill descriptions with review rubrics.
#### 🧘♀️ Solitary learners
- Present: framing that encourages solo experimentation ("do it, learn it, change it").
- Improve: a self-check worksheet for auditing your own claude.md.
#### 🌿 Naturalistic learners
- Present: light ecosystem framing (models as an "environment" you route within).
- Improve: token-as-resource lifecycle framing to reduce waste.
### 📊 Accessibility Assessment
#### Screen reader semantics
- Present: n/a for video; this note uses headings and landmarks.
- Improve: ensure the source video's description includes structured chapters.
#### Keyboard navigation
- Not applicable to this source — it's a linear video, not an interactive UI. Reason: no navigable component under test.
#### Contrast and readability
- Present: standard YouTube UI contrast for on-screen code.
- Improve: on-screen code fonts are small; larger code framing would raise readability above small-text thresholds.
#### Text resizing and reflow
- Not applicable to this source — fixed-frame video. Reason: no responsive layout to reflow.
#### Media and captions
- Present: auto-captions exist (this analysis was built from them).
- Improve: captions lacked time anchors and merged words at line breaks; a corrected, chaptered transcript and downloadable version would help.
#### Forms and interactions
- Not applicable to this source — no forms in a video walkthrough. Reason: no input controls.
#### Standards reference
- Map gaps to WCAG 2.2 AA: 1.2.2 Captions (present but low quality), 2.4.5 Multiple Ways / chapters (missing), 1.4.4 Resize text (small on-screen code).
### 🌍 DEIB Assessment
#### Cultural breadth
- Present: references to widely used tools (GitHub, React Native) accessible across regions.
- Improve: examples are US-startup-centric; global case studies would broaden reach.
#### Inclusive language
- Present: mostly plain, second-person language; jargon is defined ("intelligence," "taste").
- Improve: occasional profanity and "psychosis" framing may exclude some audiences; a plain-language summary would help.
#### Neurodiversity support
- Present: chunked into repeatable steps and consistent "here's what I did" structure.
- Improve: predictable chapter markers and icon+text labels for each phase.
#### Representation
- Present: credits collaborators (Julius, the editor) by name.
- Improve: balance the solo-hero framing with team perspectives.
#### Psychological safety
- Present: encourages experimentation and "don't be afraid to break things."
- Improve: pair the "yolo / merge with confidence" energy with clearer risk caveats for less experienced viewers.
### ✅ Logical Validity
#### Strong reasoning
- Causal (routing → cost): shifting token-heavy work to a cheaper generous-allotment model plausibly explains the ~$150 outcome; strengthened by the reported per-sub usage (<40%). Clarify further with per-task token logs.
- Inductive (min-max tips): generalizes from repeated personal runs; reasonable but sample-of-one. Clarify with A/B data.
- Analogical (reasoning slider as slot machine): vivid and apt for the "tempting but wasteful" point; not load-bearing evidence.
#### Fallacies
- Hasty generalization: "X high and max end up second-guessing themselves too much" — broad claim from personal observation; fix by citing controlled comparisons.
- Anecdotal evidence: "every single person complaining... was on X high max or Ultra Code" — self-selected sample; fix with logged usage data.
- Appeal to authority (soft): "even Anthropic agrees high is the best... it's their default for a reason" — default ≠ endorsement of "best for you"; fix by separating default rationale from optimality.
#### Tone of voice
- Enthusiastic, self-aware, hyperbolic ("psychosis," "one-shot me," "god damn"), candid about uncertainty ("this is genuinely how I feel," admitting the model wrote rules he disagrees with).
### 🛡️ DARVO Analysis
- Deny: minor — pre-empts the "nerfed/too expensive" narrative by denying it and redirecting to a companion video; also denies a special OpenAI deal ("I promise you I have no special deal").
- Attack: mild, aimed at tools not people — GitHub load times, GPT-5.5's mobile/UI weakness, haiku's uselessness; not at accusers.
- Reverse victim/offender: not present. This is a promotional/educational monologue, not a defense against an accusation. Reason: no accuser or wrongdoing framing exists to invert.
## 🎯 Conclusion
- Bottom line: Fable 5's edge is autonomy horizon, not per-step smarts. Orchestrate it, route cheap executors under it, keep reasoning on high, and gate production behind a human — then it can clear a month of backlog for ~$150.
- Next steps for readers: pin reasoning to high, add an intelligence/taste glossary and an escalation rule to your claude.md, wire a Codex-CLI route for computer-use/token-heavy work, and budget real tokens for post-merge verification with staging-only merges.
## 🔄 Refactor Appendix — I finally get Fable 5
> Density: 2–5 Literature atoms (H3), 0–3 Permanent candidates (H4).
> Defaults: 3 Literature, 1 Permanent. Resonance filter: if you can't
> articulate in one line why a claim matters, drop it.
>
> Konik claim-header rules: present tense, declarative, ≤10 words when
> possible, searchable, unique, mirrors annotation focus if present.
>
> Atomicity: one declarative sentence per atom. "and"/"also" → split.
>
> Tag pool: #bmf · #addendum · #xref · #articleseed · #storystem · #share · #aphorisms
### 📚 Literature Atoms (H3)
#### [H1] Newer agent models run further, not just smarter
> [!quote] ID:rw_fable5_h1
> Fable isn't just an improvement.
**Context & use**:
- ~02:46 — thesis of the video.
- The value shift is autonomy horizon (end-to-end implement/test/verify), not per-step intelligence; reusing Opus prompts underuses it.
**Tags**: #xref #aphorisms
**Highlight**: [view highlight](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=166s)
<!-- atomicity: 1 idea ✓ -->
#### [H2] Keep agent reasoning effort on high
> [!quote] ID:rw_fable5_h2
> High is way smarter.
**Context & use**:
- ~09:45 — cost/quality tip.
- X-high/Max/Ultra over-reason, bloat diffs, and overspend; effort is per step, not run length.
**Tags**: #xref #addendum
**Highlight**: [view highlight](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=585s)
<!-- atomicity: 1 idea ✓ -->
#### [H3] Verifying agent work can cost more than doing it
> [!quote] ID:rw_fable5_h3
> I burned way more tokens trying to verify the work that Fable did here than I burned getting Fable to do the work here.
**Context & use**:
- ~42:46 — post-merge stress test.
- Verification is the safety budget in agentic workflows; treat it as a first-class cost, not overhead.
**Tags**: #xref
**Highlight**: [view highlight](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2566s)
<!-- atomicity: 1 idea ✓ -->
#### [H4] Agents may merge to staging, never to prod
> [!quote] ID:rw_fable5_h4
> the model cannot ship or touch prod.
**Context & use**:
- ~41:19 — why "merge with confidence" is safe.
- Environment-scoped permissions (staging merges, human prod gate) make autonomous merging tolerable.
**Tags**: #xref #share
**Highlight**: [view highlight](https://www.youtube.com/watch?v=8GRmLR__OGQ&t=2479s)
<!-- atomicity: 1 idea ✓ -->
### 🧠 Permanent Candidates (H4)
#### [P1] Orchestrate a smart model; route cheap executors beneath it
**Claim** (one sentence, Courtney's voice): You get the most from a frontier coding agent by letting it orchestrate while cheaper models handle token-heavy and computer-use subtasks.
**Evidence pointer**: [[#H1]] — plus the ~$150 run where Fable steered GPT-5.5 via Codex.
**Scope & conditions**: Holds when a cheaper model has generous quota and adequate capability for the delegated subtask; breaks when routing overhead or taste-sensitive work dominates.
**Links**:
- [[Credit routing model]] — because extends
- [[Maker-checker loop engineering]] — because applies-in agent verification
- [[Reasoning-effort cost tradeoffs]] — because contrasts on cost-vs-quality dimension
<!-- atomicity: 1 idea ✓ -->
### ✏️ Fleeting Queue
- [F1] Test the "high beats X-high/Max on cost-adjusted quality" claim on a real repo before adopting as policy — https://www.youtube.com/watch?v=8GRmLR__OGQ&t=585s #fleeting #inbox
- [F2] Draft a claude.md glossary (intelligence/taste) + escalation rule as a reusable template — #fleeting #inbox
### → Things 3 (max 2 actions)
- [ ] Add a "shell out to a cheaper CLI model for computer-use/token-heavy tasks" note to global agent config — orchestration routing #things
- [ ] Add a staging-only-merge / human-prod-gate guardrail to agent permission docs — governance #things
```
Processed: I finally get Fable 5
- Literature atoms: 4 / 5 cap
- Permanent candidates: 1 / 3 cap
- Fleeting items: 2
- Things 3 actions: 2 / 2 cap
- Konik tags used: [#xref, #aphorisms, #addendum, #share]
- Triage callouts populated: [Cross Reference, Article Ideas, Aphorisms]
- Quality gates: [Verbatim ✓, Atomicity ✓, Link annotation ✓, YAML hygiene ✓, Konik triage ✓, Version Diff ✓]
- Override conditions triggered: [none]
```
<!-- deep-read:sections end -->
📄 **Full text:** [[Full Document Contents/Articles/I Finally Get Fable 5.md|I Finally Get Fable 5 by youtube.com]]
## Highlights
- Fable isn't just an improvement. ([View Highlight](https://read.readwise.io/read/01kx4455y42fdypvth2ndwzffg))
- Note: Thesis: value is autonomy horizon, not per-step smarts.
- Tags: atom/literature/h1
- High is way smarter. ([View Highlight](https://read.readwise.io/read/01kx445fd342rw7j93tqh71bxw))
- Note: Core cost tip: don't push reasoning past high.
- Tags: atom/literature/h2
- the model cannot ship or touch prod. ([View Highlight](https://read.readwise.io/read/01kx445xg1rmfbwj68k6cqx5x5))
- Note: Staging-only merges make autonomous merging safe.
- Tags: atom/literature/h4
- I burned way more tokens trying to verify the work that Fable did here than I burned getting Fable to do the work here. ([View Highlight](https://read.readwise.io/read/01kx445rbjckg2fm3hnh7g06n6))
- Note: Verification is a first-class cost in agentic runs.
- Tags: atom/literature/h3