Fable 5 + GPT 5.6 Sol = CHEAT CODE
TL;DR
Chase AI's argument is that "which model is better" is the wrong
question, and he ships a Claude Code skill family
(/grill-me-codex, /codex-build) that runs a
four-stage pipeline instead: Fable interviews the operator (Matt
Pocock's grill-me), Fable and OpenAI Codex argue the plan to consensus
over a capped number of rounds, Codex writes the code from the frozen
plan, and Fable reviews the diff like a contributor PR — with a bounded
two-round repair loop before Fable takes the wheel itself. The
load-bearing idea is not the token saving the title advertises but the
independence claim the skill's own README makes:
the same model that plans the build and writes the build can't be
trusted to grade its own work — it's an echo chamber; a different
provider catches what Claude structurally can't see in itself. That
is a direct, on-the-record answer to the open question this vault
already carries on Adversarial Planning
Council — whether persona diversity on one model substitutes for
genuine model diversity — and it comes down hard on the model-diversity
side, with the cross-vendor role swap (nobody grades their own
work, in both directions) as the mechanism. The economics are the
secondary argument and the weaker one: the source asserts GPT-5.6 Sol
benchmarks ahead of Claude Fable 5 and is cheaper than Opus, so the
executor slot in a planner/executor split should be filled by a rival
vendor's model rather than by a smaller model on your own vendor's
ladder — which is where the source explicitly breaks with Advisor Mode, the pattern he himself put in
this vault.
Concepts introduced
- Cross-Model Independence — the durable principle underneath the whole skill: a checker drawn from the same model as the author is correlated with what it is checking, so independence must be bought along the provider/lineage axis, not merely by changing the prompt or persona.
- Bounded Negotiation with Fallback — the control primitive that makes cross-model argument shippable rather than open-ended: cap the rounds (5 for planning consensus, 2 for review-repair) and define what deterministically happens when the cap is hit (Fable stops asking and fixes it itself).
Held, not dropped — themes this capture touches that do not warrant a concept page yet:
- Meter arbitrage across vendor subscriptions — the source's real cost mechanism is that Fable draws down a scarce weekly Claude limit while Codex bills a different subscription, so offloading execution moves burn onto another meter rather than reducing total spend. This is adjacent to but not the same as Model-Tier Routing (which routes by capability tier); spin out if a second source treats the subscription meter, rather than $/token, as the thing being optimized.
- The grill-me lineage as a skill supply chain —
grill-me-codexis built on Matt Pocock's MIT-licensedgrill-me/grill-with-docswith Act 2 and Act 3 added, and Act 3's delegation pattern adapted from Peter Steinberger'scodex-first. Attribution-and-fork as the distribution mechanic sits near Public Skill Adoption and Skill Artifact Transfer; held pending a source that treats the derivation chain itself as the subject. - The GPT-5.6 Sol benchmark package — TerminalBench 2.1 / GeneBench v1 figures from OpenAI's own preview page. Held as source-claimed observations below, not as a concept.
- The Trip Atlas demo app — the artifact built (offline GeoNames city DB, SVG + d3-geo + GSAP, cinematic replay) is a vehicle for the workflow, not knowledge about the workflow.
- "Fable kind of off the market" — the source's aside that the pipeline hedges against losing access to the premium model. Market-risk speculation; held.
Key claims
- A model cannot be trusted to grade work it authored — same-model review is an echo chamber, and a different provider catches what a model structurally can't see in itself. principle — Cross-Model Independence. The source's central justification, stated in the skill's README as the answer to "why a second model?".
- Cross-model checks must run in both directions — nobody grades their own work. principle — Cross-Model Independence. Codex critiques Fable's plan (Act 2); Fable reviews Codex's diff (Act 4). The independence is symmetric, not a one-way audit.
- Cap the rounds of cross-model argument and define the terminal action: 5 iterations to plan consensus, 2 review-repair rounds, then the reviewer stops asking and fixes it itself. best practice — Bounded Negotiation with Fallback. Context: two capable models negotiating over one artifact, where the failure mode is a non-terminating loop and the operator is paying per round. The specific numbers (5, 2) are this skill's tuning, not a law; the bound plus a deterministic fallback is the durable part.
- Write the argument to a file and record resolutions with
reasons —
PLAN-REVIEW-LOG.md, "11 accepted, 1 scoped down with logged reason". best practice — Bounded Negotiation with Fallback, Decision Log. Context: multi-round automated negotiation the operator did not watch; the log is how a bounded argument stays auditable after the fact. - "Which model is better?" is the wrong question; the question is how to use two powerful models together. principle — Cross-Model Independence. The source's framing device, and the thesis the whole skill instantiates.
- Fill the executor slot in a planner/executor split with a rival vendor's model rather than a smaller model on your own vendor's ladder. best practice — Model-Tier Routing, contra Advisor Mode. Context: an operator holding both subscriptions, and contingent on the source's benchmark claims holding. The source: "why have Opus execute if at the same price I could have 5.6 do it?… I think this is way better than passing things off to Opus or to Sonnet or using advisor mode inside of Claude Code."
- Front-load an interview that asks one question at a time and
recommends an answer each time, using the operator's own history as
context. best
practice — Spec-Driven
Development. Context: greenfield work where the operator hasn't
decided what they want; "plan mode on steroids," ~8–10 questions.
Inherited from Matt Pocock's
grill-me, not original to this source. - GPT-5.6 Sol scores 88.8% (Sol Ultra 91.9%) on TerminalBench
2.1, ahead of Claude Mythos 5 at 88.0%, Claude Fable 5 at 84.3%, and
Claude Opus 4.8 at 78.9%.
observation — the source's
claim, read off OpenAI's own
previewing-gpt-5-6-solpage and hedged on camera as vendor-published ("grain of salt, this is coming from OpenAI"). Groundable; flagged for a later verification pass, not adjudicated here. - On GeneBench v1, GPT-5.5 at Xhigh reasoning effort scores 22.94% at $1.24 API cost, while GPT-5.6 scores ~25% at ~$0.56 — higher score, less than half the cost. observation — the source's claim, from the same vendor page's cost curve (the $1.24/22.94% figure is legible in the on-screen tooltip; the 5.6 figure is spoken, not shown in a sampled frame). Groundable; not adjudicated here.
- On DeepSWE (deepswe.datacurve.ai), gpt-5.5 [medium] plots above claude-opus-4.8 [high] on both pass rate and cost per task — and claude-fable-5 [high] plots above both. observation — the first half is the source's spoken claim; the second half is visible in the same frame and unremarked by the narration. Third-party chart rather than vendor-published. Groundable; not adjudicated here.
- The full four-stage run — interview, two rounds of adversarial planning, Codex build, Fable review — consumed ~130,000 tokens on the Fable side; planning converged in 8m 14s. observation — the source's claim from his own session; a single unreplicated run with no all-Fable control to compare against, so the headline "saving tokens in the aggregate versus having Fable do everything" is asserted, not measured.
- Fable 5 is metered against a weekly Claude usage limit (up to 50% of it, through July 12) and draws down that limit faster than Opus 4.8. observation — read off the Claude Code session banner at t=05:21; a product/pricing fact with a date on it that will drift. Groundable; not adjudicated here.
grill-me-codexis derived work: Act 1 is Matt Pocock's MIT-licensedgrill-me; Act 3's delegation pattern is adapted from Peter Steinberger'scodex-first; the repo carries 378 stars and 41 forks. observation — read off the README and repo header at t=09:30.
Why this refines the graph
On Adversarial
Planning Council — this source closes an open question the page has
been carrying. That page records a live tension: Karpathy's
original council polled different LLMs, but
llm-council-skill runs five personas on a single
model and its author reports it "still works quite well" — logged as
"asserted from use, not measured — a testable refinement, not a settled
result." The page then sharpens the doubt itself: an author-constructed
panel on one model with a shared framing yields correlated, not
independent judgments, so agreement across lenses is "a strong
hypothesis, not independent proof." This source takes the other horn and
states the reason plainly: the echo chamber isn't a prompt problem, it's
a lineage problem — "a different provider catches what Claude
structurally can't see in itself." It does not settle the question
empirically (no measurement is offered either way), but it converts the
vault's suspicion into a named counter-position from a practitioner who
shipped on it, and it supplies the mechanism the persona-only council
lacks: the critic is a different vendor's model, so its blind spots are
uncorrelated by construction rather than by instruction. Two related
refinements come with it: the council here runs on two members
rather than a roster of five (see Bounded
Fan-Out — model diversity may buy with two what persona diversity
needs five to approximate), and the council's verdict vocabulary shifts
again — not Go/Reshape/Kill, but converge-or-cap.
On Model-Tier Routing —
the second tier here isn't a lower tier. That page already
holds cross-vendor delegation as a routing target
("/codex:rescue, /codex:transfer to delegate
to GPT-5.5"), but frames the split as capability tiers: premium
model plans, cheaper-and-dumber model executes. This source routes
across vendors to a model it claims is not weaker — the
argument is that the executor slot should go to a peer on a different
meter, chosen for independence and for which allowance it burns. That is
a genuinely different selection criterion than "cheapest tier that
clears the bar," and it stacks with the page's existing "expensive boss
that never codes" org-chart framing rather than replacing it.
On Advisor Mode — a tension
inside the vault, from the source that put the concept here. Advisor Mode was distilled from
make-fable-5-80-cheaper-other-usage-cheat-codes — the
same channel. That page holds: a cheap executor consulting a
smarter advisor when stuck beats the cheap model solo on both score and
cost (Sonnet 4.6 High + Opus advisor, 74.8% @ $0.96 vs 72.1% @ $1.09).
This video asserts the opposite recommendation: "I think this is way
better than passing things off to Opus or to Sonnet or using advisor
mode inside of Claude Code, because these GPT models are just better
than those smaller Anthropic models and they are cheaper." The tension
to resolve is narrow and worth stating precisely: the video does
not dispute advisor mode's measured result, and does
not dispute the planner/executor shape — it disputes the executor
selection, arguing the in-vendor ladder is dominated by a
cross-vendor option. Both positions can hold simultaneously only for an
operator paying for both vendors; for a Claude-only operator, Advisor Mode remains the live option and
this video's route is unavailable. Neither side is adjudicated here; the
deciding evidence would be the benchmark claims above, which are
vendor-published and unverified. Note also that the two sources are not
independent — same channel, ten days apart — so this is one practitioner
revising his own recommendation, not two sources disagreeing.
On Spec-Driven Development — corroboration, not news. The grill→plan→implement→review pipeline and the "plan mode on steroids" interview are already on that page as a fixed pipeline of named skills, credited to the same upstream author (Matt Pocock). This source is a third instance of front-loading attention onto the plan; it adds the cross-model hardening step between spec and implementation, and nothing else new.
Illustrated walkthrough
t=00:57 — the benchmark case, hedged in the same
breath. On screen:
openai.com/index/previewing-gpt-5-6-sol/, a TerminalBench
2.1 bar chart reading GPT-5.6 Sol Ultra 91.9%, GPT-5.6 Sol 88.8%, Claude
Mythos 5 88.0%, GPT-5.6 Terra 84.3%, Claude Fable 5 84.3%, GPT-5.5
83.4%, GPT-5.6 Luna 82.5%, Claude Opus 4.8 78.9%, Gemini 3.1 Pro Preview
70.7%. Said over it: "Soul 5.6 is wildly powerful, at least
according to the benchmarks. Now, grain of salt, this is coming from
OpenAI." The source flags its own vendor-published evidence —
worth preserving, since the whole cost argument rests on this chart.
t=01:49 → 02:02 — the token-efficiency curve. A
GeneBench v1 score-vs-API-cost plot; the hover tooltip at 02:02 reads
Model: GPT-5.5 · Reasoning effort: Xhigh · API Cost (USD): $1.24 · Score: 22.94%.
Narration rounds this to "23% at $1.24" and contrasts "5.6 is a 25%
score… at 56 [cents]. So way cheaper and therefore way more
efficient."
t=02:20 — the frame that says slightly more than the
narration. On screen: deepswe.datacurve.ai,
DeepSWE score against avg cost per task. Narration: "direct
comparisons of 5.5 versus Opus 4.8 — there's really no contest. Higher
pass rates, lower cost." The plotted curves do show
gpt-5.5 [medium] above claude-opus-4.8 [high],
supporting that specific claim — and the same chart also plots
claude-fable-5 [high] above both, at ~68–70%,
which the narration does not mention. The source's argument is about the
executor slot, where Fable is not the candidate; noted because
the visual channel carries a comparison the audio doesn't.
t=03:00 → 04:30 — the pipeline, drawn. An Excalidraw
board titled /codex-build & /grill-me-codex, built up
across three sampled frames into: 1) Interview
[grill-me] ← annotated Fable; 2) Adversarial
planning ← annotated F ⇄ Codex (arrows both ways);
3) Codex builds; 4) Fable Reviews (an
arrow loops back from 4 to 3). Spoken alongside: Fable is "driving the
ship"; Fable and Codex "go back and forth for a maximum of five
iterations… till they reach a consensus"; and at review time Fable will
tell Codex "you did that wrong, fix it" — "it's going to do that twice.
If by the third time it's not complete, well then Fable will clean it up
itself." The 60 s hole sits inside this stretch.
t=05:21 — the run starts, and the meter is visible.
A Claude Code v2.1.204 session:
Fable 5 with high effort · Claude Max, and a banner reading
"Extended: Fable 5 is included in your weekly limit —
Through July 12, you can use up to 50% of your weekly usage limit on
Fable 5… Fable 5 draws down usage faster than Opus
4.8." Below it:
/grill-me-codex Build "Trip Atlas" — a stylized, cinematic trip planner web app.
That banner is the unstated premise of the entire video: the thing being
conserved is a weekly allowance, not a dollar bill.
t=06:00 — Act 1 interviews, and recommends.
Grill-me-codex Act 1 start… Will interrogate one question at a time, recommend an answer each time.
Q1 — What is this FOR? with three options (video demo /
real personal tool / shippable product) and, crucially,
My recommendation: A with B's bones. Your pattern (localflow, chomp, jarvis-hud) = build real working thing, video is the payoff.
The interview isn't neutral elicitation — it reads the operator's own
history and argues for an answer, then asks "Which is it?"
t=07:00 — consensus, logged.
Converged: APPROVED, 2 rounds. Artifacts at ~/projects/trip-atlas/ — PLAN.md (final) + PLAN-REVIEW-LOG.md (full argument).
The summary: Act 1 locked identity; Act 2 round 1 (Codex, 12
findings) hardened the data core — stable
geonameId round-tripping, civil-date strings killing TZ
off-by-ones, antimeridian splitting, a replay-vs-edit race fixed via
trip snapshot, pins moved into SVG ("killed whole DOM-sync problem
class") — 11 accepted, 1 scoped down with logged
reason; Act 2 round 2 approved with 3 non-blocking notes folded
in. Brewed for 8m 14s. Then the fork: "Grilled + survived 2
rounds of Codex. Implement now — Codex builds it
(/codex-build), Claude builds it, or stop here?" Two
details do real work here: the argument is written to a file
(PLAN-REVIEW-LOG.md), and disagreement is resolved and
recorded (11 accepted, 1 rejected with a logged
reason) rather than deferred.
t=07:30 — the handoff.
Skill(codex-build) — Successfully loaded skill.
t=08:30 → 09:00 — the artifact. Trip Atlas at
127.0.0.1:5173: "The Brass Compass Route", a parchment
vector world map with numbered pins, a stops panel (Lisbon / Istanbul /
…), 3 stops · 17 days · 6,680 km, an
Offline DB marker on the city lookup, and a Cinematic
Replay mode. Verdict spoken: "not bad, I think, for the first pass… what
this really was about was just showing this workflow in action." Then
the number the title is selling: "we only burned up about
130,000 tokens on the Fable side to get this whole
thing done."
t=09:30 — the README states the real thesis.
github.com/chaseai-yt/grill-me-codex (378 stars, 41 forks):
"Two AI models harden your plan — then swap jobs to build
it.… Act 3 (optional) flips the roles: Codex writes the
code from the frozen plan while Claude reviews the
diff like a contributor PR. Cross-model checks in both
directions — nobody grades their own work." And the
block quote: "Why a second model? Because the same model that plans
the build and writes the build can't be trusted to grade its own work —
it's an echo chamber. A different provider catches what Claude
structurally can't see in itself." Credited: built on Matt Pocock's
grill-me / grill-with-docs (MIT, Act 1 is his
work); Act 3's delegation pattern adapted from Peter Steinberger's
codex-first.