Big Idea

The argument in one line.

Every Claude Code and Codex session is stored as a tagged JSONL file on your machine, which means Fable's planning and tool rhythms can be measured, compared against other models, and distilled into a reusable playbook that improves how any model behaves in your editor.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You used Claude Fable 5 and want to carry its behavioral patterns forward into Opus, Codex, or open-source models.
You run long agentic Claude Code sessions and want to understand your model's actual tool-use habits from session logs.
You already work inside Claude Code daily and are comfortable running Python scripts from a terminal.
You never got Fable sessions but want to run the same analysis against open-source data from Hugging Face.

SKIP IF…

You have never used Claude Code or Codex -- the JSONL files this relies on are generated by those tools.
You are looking for a one-click prompt tweak rather than a multi-step analysis-and-injection workflow.

TL;DR

The full version, fast.

Claude Code and Codex store every conversation as a JSONL file that includes which model produced each turn. By writing a small Python debloat script, filtering to Fable-5 turns, and running a behavioral analysis, you can produce machine-readable stats -- tool-use rate, read-before-edit ratio, parallel batching cadence -- and put them side by side with your current model's stats. The delta becomes a playbook .md file you inject at session start via a hook, a skill, or CLAUDE.md. The result won't replicate Fable's weights, but it can meaningfully tighten how any model plans and sequences work.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:40

01 · The taste of Fable, and the promise

FOMO hook establishing Fable withdrawal; previews the playbook-from-logs solution.

00:40 – 01:15

02 · JSONL files full of gold

Every Claude Code and Codex conversation lives as a JSONL file on disk, tagged by model.

01:15 – 01:48

03 · Turn them into a playbook

High-level preview of the end state: from raw JSONL to a model-agnostic playbook.

01:48 – 02:12

04 · Build scripts to distill what matters

Strip tool results, file echoes, command output; keep timestamps, model ID, prompts, and responses.

02:12 – 02:37

05 · Filter by model tag

The message.model field lets you filter Fable turns vs. Opus turns in any session history.

02:37 – 03:07

06 · No Fable history? Use the open-source dataset

Hugging Face archive of real Fable 5 sessions available for anyone without their own data.

03:07 – 03:40

07 · Count your files first

Opening prompt: how many JSONL files exist across all projects? (~2,881 here). Sets scope before filtering.

03:40 – 04:22

08 · Strip the bloat

Prompt for a Python debloat script that removes heavy payloads and outputs a clean transcript.

04:31 – 05:08

09 · Pull every Fable turn

Filter on model name; aggregate all Fable-5 turns from all projects into one combined corpus.

05:08 – 05:34

10 · Measure behavior in real numbers

Ask for stat-based behavioral patterns rather than qualitative impressions.

05:34 – 06:05

11 · Fable working rhythm stats

91.3% tool-use rate, 1.13 tools/turn, 65.5% read-before-edit, 6.3% truly-blind edits.

06:05 – 06:37

12 · Fable vs your model, side by side

Run the same analysis against Opus 4.8 and generate a side-by-side comparison table.

06:37 – 07:07

13 · Reading the comparison table

Fable: 4,821 turns, 54.4% deliberates before acting. Opus: 25,540 turns, 33.3% deliberates.

06:59 – 07:26

14 · Where Opus falls short

Opus takes more turns for similar problems and plans less before acting -- this is the delta to close.

07:26 – 07:48

15 · Distill it into a playbook file

Ask Claude to distill all behavioral findings into a single .md playbook file.

07:48 – 08:45

16 · Inject with a hook, skill, or CLAUDE.md

Three injection paths for the playbook: drag-and-drop per session, hook at session start, or CLAUDE.md.

08:45 – 09:37

17 · Grab the free kit

CTA: free Gumroad kit with prompts, open-source dataset link, and the host playbook.

Atomic Insights

Lines worth screenshotting.

Every Claude Code and Codex conversation is stored as a JSONL file on your local machine, tagged with the model that produced each turn.
90% of a JSONL session file is bloat -- tool results, file echoes, command output -- and stripping it leaves a clean lightweight transcript a fraction of the original size.
Fable used at least one tool in 91.3% of its turns; the key differentiator is not tool-use rate but planning depth before acting.
Fable thought before acting in 54.4% of turns versus Opus's 33.3% -- the deliberation gap is the most concrete behavioral difference between the two models.
Fable had a 6.3% truly-blind-edit rate (editing without reading first); Opus's rate was only 1.9%, making Opus the more cautious reader.
The message.model field in every JSONL turn lets you filter an entire multi-project history down to only the turns produced by a single model ID.
You do not need your own Fable session history -- an open-source Hugging Face archive of real Fable 5 sessions is publicly available for running the same analysis.
A behavioral playbook derived from your own session logs is more calibrated to your workflow than any generic system prompt, because it is trained on how you actually use the model.
Injecting a playbook file at session start via a hook, a skill, or CLAUDE.md costs nothing and applies to every model you use without changing the underlying weights.
Measuring model behavior as ratios and counts rather than impressions makes it possible to track whether a playbook injection actually shifted the numbers over time.

Takeaway

Your session logs already contain a model's behavioral fingerprint.

WHAT TO LEARN

The difference between how two models plan, sequence tool calls, and edit files is measurable -- and measuring it is the first step to closing the gap.

Claude Code and Codex store every turn as a JSONL file with a model tag, which means you can filter an entire project history down to one model's behavior in a single script.
Stripping the bloat from JSONL files -- tool results, file echoes, command output -- reduces them by roughly 90% and leaves a clean transcript suitable for analysis.
Behavioral differences between models are most useful when expressed as ratios and counts: tool-use rate, read-before-edit percentage, and truly-blind-edit rate are all measurable from session logs.
Fable deliberated before acting in 54% of turns versus about 33% for Opus -- a gap that a playbook file can partially close by prompting more upfront planning.
Injecting a context file at session start via a hook or CLAUDE.md costs nothing and applies to every project without touching model weights.
When you lack your own data for a model, open-source session archives on Hugging Face let you run the exact same behavioral analysis on someone else's logged conversations.
A playbook derived from your own session logs is more useful than a generic prompt because it reflects your actual project types, your prompting patterns, and the tools you actually call.
The session start hook is the highest-leverage injection point: it runs before you type anything, which means every conversation benefits without requiring you to remember to add context manually.

Glossary

Terms worth knowing.

JSONL: JSON Lines format -- a text file where each line is a separate JSON object. Claude Code and Codex store every session message, tool call, and model response as one line per event in these files.
message.model: A metadata field inside each JSONL turn that records which model (e.g., claude-fable-5, claude-opus-4-8) produced that specific assistant response.
Read-before-edit ratio: The fraction of file edits where the model read the file first before modifying it. A high ratio indicates more deliberate, context-aware changes.
Truly-blind edit: An edit made by the model without any prior read of the target file in that session. Lower is generally better as a quality signal.
Claude Code hook: A configuration in Claude Code that automatically runs a command or injects content at a defined lifecycle event, such as the start of every new session.
CLAUDE.md: A project-level markdown file that Claude Code reads at session start as standing instructions. Lines added here are automatically injected into every session context.
Behavioral playbook: A distilled set of operating principles derived from observed model behavior -- written as instructions the model reads to align its planning, tool use, and editing patterns with a reference model.

Resources

Things they pointed at.

02:37linkHugging Face Fable 5 open-source session dataset

09:09productFree kit (prompts + dataset + playbook) ↗

09:09productEarly AI Adopters community ↗

Quotables

Lines you could clip.

02:12

“All of these files actually tag which model sent which response.”

Reveals a non-obvious feature of JSONL files that makes the entire workflow possible→ TikTok hook↗ Tweet quote

05:08

“Give me the behavioral patterns as real measured numbers, not just impressions.”

Quotable principle that applies far beyond this specific workflow→ IG reel cold open↗ Tweet quote

07:11

“You still won't get Fable five performance, but you can get a much stronger Opus execution.”

Honest expectation-setting that makes the promise feel credible rather than oversold→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphorstory

So if you're feeling the withdrawal effects of not using Fable five or even the FOMO of not having the chance to play with it before we lost it, then the last few days have definitely been rough. We had a taste, a glimpse of what a super intelligent PhD level scientist looks like living in your editor. Now, can't help you get the power of Fable back because that power lies in the raw model itself.

But I've hacked away that you can use your existing Claude and Codex models and just get them to behave a lot more like Fable in just a few steps. And you can even apply what I'm about to show you to your open source models to get them to be that much more functional. So if you want the second best thing until we get our super intelligence back, then let's dive in.

Alright. So the average person doesn't know that the majority of your conversations, whether they're codex or Claude code, live in what are called JSONL files on your computer.

And they're basically these behemoth files that are full of tool calls, metadata. And within this metadata is a series of gold that you can mine. And this file is one example of one session full of said metadata.

And you can see right here, these are all my MCP tool calls. But within here, you can also find things like the prompts that you've sent to a model as well as what the model responded with and how it actually planned out its tasks along with the tool calls it made. So what you can do is have Cloud Code parse through all of your conversations to go from something like this to something like this.

We have a full playbook that you can give pretty much any model, whether it's open source or closed source and have it either injected at the beginning of a session using something like a hook or you refer to it in the middle of the session to get that model to behave that much more like Fable did. Now like you would have seen, the majority of that file was pretty much irrelevant to us.

And while you could theoretically load hundreds of JSONL files within a conversation, you're gonna unnecessarily bloat it with information that doesn't help you at all. So what you can do is, and I'll show you in a second how you can do this in a terminal, is ask Claude Code to build a series of scripts to already preemptively parse through and only distill the information that matters and takes that information and then analyze it for all the behavioral differences between different models.

And this process would allow you to go from thousands of lines to only a fraction of that, and that fraction is what we can feed these language models. And the trick here is that all of these files actually tag which model sent which response. So we can filter down something like Opus 4.8 conversations against Fable five conversations to see the disparity of how they behaved, what tools they called, how they planned out their sessions, and try to imitate the delta.

Now before I hop into the terminal, what if you barely had a chance to even have conversations with Fable? You'd have no data to actually analyze to begin with. What you could do is go to this link in Hugging Face, and there are a series more like it where people have actually open sourced their sessions that they've had with Fable five so you can go through them and do the exact same exercise even though it's not your specific information or your specific projects.

And no need to screenshot the link. I'll make it available along with a few other things in the second link down below. Now popping into the terminal, I'm gonna walk you through the handful of prompts that you can use to get to that synthesis file that you can use however you want.

So in this case, we can start off with asking how many JSONL files do we have from all of our sessions? And I asked us to see what is the blast radius? How many files do we have in the entire universe of our usage?

Now one key caveat here is only a small fraction of those would be Fable five. So I'm just trying to get a sense for how many so I can then tell it to focus on that specific filter. So in our case, we have close to 3,000 JSONL files across all of our projects.

Then once you understand that, you can send a prompt just like this. So you could basically say the bloat in these files is the tool results, the full file contents and command output that get echoed back into context.

Key thing, write me a small Python script, you can name it whatever you want, that takes a Cloud Code session file and strips all the lightweight transcripts. So leave me with things like the timestamps, which model it was, what did I ask for, and what did the actual assistant respond with.

Now if you're trying this for the first time, have it just do one specific file so you can make sure that it's the exact format they're expecting. And once it parses through, it will give you this resulting file. You can take a peek at it, and like I said, make sure it's what you're expecting.

So in my case, I redacted some information, some personal information, but then it leaves you with the transcript, the back and forth between you and the agent. And you can also add different metadata like all the tool calls like you can see here.

Here are exactly what tools it executed in what order. You can see this is the assistant and that specific model. So you can easily then go to the next step, which is parse the model based conversations that matter.

So then you can send a prompt like this where we basically tell it that every single conversation has this artifact that's called message model, which we just saw right now. Pull every turn that came from Claude Fable five, the exact model name, out of my whole history across all of my projects into one combined corpus.

So, basically, create a full playbook of every single conversation that I had using this model and all of the preamble or the context around that conversation. And on top of that, you can ask it to do some synthesis. So I say, give me the behavioral patterns as real measured numbers, not just impressions.

So something that is tangible versus just an intangible objective look at the quality of the conversation. Now since we created a sample script before, it's way faster to go from that point to this point where we have that completed file that has all the artifacts across all 10,000 records, and then you can see all the volume of messages.

It walks through and breaks down the numbers around tool use, the order of work. So one thing that you wanna emulate using Opus or Codex or even your open source models is how disciplined Fable seem to be around using the right tools at the right time. And you can learn a lot from its rhythms.

You can even see its working rhythm here is being analyzed. This transitions between using different bash commands, chaining different steps, the way it read and edited files, everything seemed to be a little bit more elegant, a little bit more refined and precise from something like Opus. And once you have that, this is the key distinction.

Depending on whatever model you used alongside Fable before Fable came out, let's say it's Opus 4.8, it could be Opus 4.7, or even Haiku. You can say, now run the exact same behavioral read against insert name of model here and put the two side by side. Show me the distance between their rhythm, the tool call cadence, the action sequences, and the ratios like reads before edits and tests after edits.

So we're trying to emulate the entire structure of how Fable executed things. Once you get that full breakdown, it'll go and basically edit its script, and it will come back with an overall summary like you can see here. So you can see this is the side by side compare of Fable five and Opus 4.8 on your specific computer.

Again, if you don't have enough history to have enough training data for this Fable analysis, you could use that open source example I showed you earlier. And when you go to the bottom here, if we scroll back up, you can see that for very similar problems, there were many more turns taken by Opus 4.8. A lot of times, it doesn't think before it acts as much as fable.

So a lot of these, again, we can't change because they come from the model weights itself. But if you can implore or elicit Opus to think that much longer or plan a little bit longer to be a lot more thoughtful, you still won't get Fable five performance, but you can get a much stronger Opus execution. Once you finish the analysis, you can ask it to distill all of its core findings of how Opus could act more like Fable in something like a Playbook file.

And what you could do is you can open a brand new session and refer to said file by tagging it, or you could actually attach it to a hook. So you could tag the ClaudeCode guide agent, and let's say we go into a brand new terminal session and we spin this up. Like I said, you could just bring the file in and drag and drop it, or you could say, I want to use the learnings from name of file.

Let's call it dot m d. And I want it always injected at session start.

So in this case, you could say, c c, the Claude code guide agent right here. And I could say, attach a hook at the session start event to always inject this into context.

Now, alternatively, you could turn this into a skill. You could turn it into a series of lines in your CloudMD that are already auto injected in every session.

There are different ways to go about integrating this that really depend on your day to day workflow. But the bottom line is you can improve the performance of all of your models by giving it something like this playbook. And to make it easier for you, I will give you my playbook as well if you wanna skip this whole process and just take the synthesis of what I've observed through my Cloud Code sessions.

And that's pretty much it. So we can't clone the power of Fable five, but you can do a few things to at least improve the models that you currently have in the meantime while we wait for all this to play out. Like I said before, you'll be able to find all the prompts I walked you through along with that link to the open source dataset along with that little guide I showed you right now in the second link down below.

And if you always wanna be on the front foot with things like Cloud Code and Codex and AgenTic workflows in general, then check out the first thing down below for my early AI adopters community. They already got a preview of this trick before I put it all together. So if you always wanna be ahead of the game, then make sure to check that out.

And for the rest of you, if you found this helpful, I'd super appreciate a like and comment on the video. It helps the reach, helps the channel, and I'll see you in the next one.

The Hook

The bait, then the rug-pull.

When Fable 5 was pulled, it left a measurable gap -- not just a feeling. This breakdown traces the exact technique for quantifying that gap using the JSONL session logs already sitting on your machine, then closing it with a playbook that works across any model.

Frameworks