Big Idea

The argument in one line.

Public benchmarks test websites and math problems that barely overlap with real work, so mining your own chat history into a personal, repeatable rubric is the only reliable way to know whether a new model is worth switching to.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code, Codex, or a similar AI tool daily for real work and have accumulated a large history of past conversations.
You feel model-launch fatigue — a new release drops and you don't know if it's actually worth adopting or just noise.
You want a repeatable, personal way to decide between effort levels or models instead of trusting public leaderboard scores.
You're comfortable running a Claude Code slash-command skill and reading a generated report.

SKIP IF…

You're a casual or occasional AI user without an existing chat history worth mining.
You're looking for a ranked verdict on which model is 'best' — this teaches a personal methodology, not a universal answer.

TL;DR

The full version, fast.

Every model launch triggers the same wave of tutorials: throwaway demos and recited benchmark scores from tests — coding arenas, math olympiads — that rarely resemble real work. This video replaces that ritual with a personal benchmark: feed your archive of past Claude or Codex conversations into the AI, let it isolate the tasks you actually run — emails, audits, briefs — and freeze them into a reusable test pack. Add a personal rubric scoring quality, instruction fidelity, token cost, speed, and turns, and one slash command replays your real work against any new model, reporting in 30-40 minutes whether it's actually worth switching or just noise.

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:42

01 · The weekly model-drop ritual

Opens with the familiar cycle of a new model dropping and a flood of interchangeable tutorials building throwaway demos and reciting benchmark numbers that don't mean anything for the viewer's actual work.

00:42 – 01:06

02 · The better way: benchmark your own work

States the video's promise: instead of watching another tutorial, viewers will get a slash command that runs their own benchmark against real work so they can judge new models for themselves.

01:06 – 01:35

03 · Why public benchmarks never sampled your life

Public benchmarks like Web Dev Arena, Math Olympiad, and SVG Unicorn tests measure a different population of tasks entirely, with almost no overlap with real work like client emails, audits, and reports.

01:35 – 02:40

04 · Mining chat history into real tasks

Explains feeding an archive of past Claude/Codex conversations — over 1,000 threads and several gigabytes — into the AI so it can isolate the recurring tasks a person actually executes day to day.

02:40 – 03:28

05 · Building your own rubric

Warns that letting a model grade itself introduces bias, so the fix is defining a personal rubric first, then turning the mined history into a reusable, weighted test pack.

03:28 – 03:47

06 · Introducing the /benchmark command

Once the rubric and test pack exist, comparing any two models becomes a single typed command that kicks off the automated evaluation.

03:47 – 04:50

07 · Live demo: Opus 4.8 vs Opus 5 on copywriting

Runs the actual terminal demo, comparing Opus 4.8 on low effort to Opus 5 on low effort for a copywriting task, then confirming the test plan and effort levels before trials begin.

04:50 – 05:11

08 · The live progress page

Once trials launch, a browser dashboard spins up and tracks each model's session in real time, confirming both models are executing at the correct effort level.

05:11 – 05:33

09 · The three trials

Walks through the three separate benchmark runs queued up: one isolating a single email-triage task, one comparing low vs. high effort across two models, and one generic run left to the model's own judgment.

05:33 – 06:07

10 · Reading a completed report

Opens a finished benchmark report showing a single task tested to a dead-even result between Fable 5 and Opus 5, illustrating that one tied test isn't enough evidence to justify switching models.

06:07 – 06:37

11 · The five-dimension rubric explained

Breaks down the personal rubric into five measurable numbers — quality, instruction fidelity, tokens used, speed, and number of turns — so 'better' is judged on multiple axes instead of one vague impression.

06:37 – 07:35

12 · Task-by-task results and verdicts

Reviews several completed comparisons, including a four-way Opus 5 vs. Fable 5 test at low and high effort on a debugging task, where instruction-following and a 'soul' score separate the models more than raw quality.

07:35 – 08:16

13 · Grab the free skill and wrap-up

Closes by pointing viewers to the free downloadable /benchmark skill and the paid Early AI-dopters community for going deeper, then asks for a like and comment.

Atomic Insights

Lines worth screenshotting.

Public benchmarks like Web Dev Arena, Math Olympiad, and SVG Unicorn tests measure websites, games, and math problems that almost never overlap with the emails, audits, and briefs that make up most people's actual work.
One pass over 1,000+ saved AI conversations (roughly 1.6 GB of chat history) can be mined into a reusable test pack of around 199 unique recurring task patterns.
Letting an AI grade its own output introduces bias, so a personal benchmark requires writing your own rubric for what 'better' means before running any comparison.
A personal benchmark rubric scores a model on five separate numbers instead of one: quality, instruction fidelity, tokens used, speed, and number of turns.
In one benchmark run, Opus 4.8 scored 83% on instruction fidelity while delivering about 0.65 quality points per 1,000 tokens.
On a single tied task, Fable 5 and Opus 5 came back statistically dead even — Fable 5 scored slightly higher on quality (7.2 vs 7.0) and used tokens more efficiently, but one tied test isn't enough data to justify switching.
Fable 5 was measurably chattier in testing, averaging 449 words versus Opus 5's 302 words for the identical task — about 49% wordier.
In a four-way test on a debugging/patch task, instruction-following separated the models more than raw quality: Fable 5 at low effort passed every check while Opus 5 low, Opus 5 high, and Fable 5 high each missed one.
Opus 5 at high effort scored highest on a 'soul' metric (how human the writing reads) at 9.5, with a more narrative explanation style than the other models' terser tone.
Running a full personal benchmark against a new model — three trials, from typing one slash command to reading the finished report — takes about 30-40 minutes.

Takeaway

Build a rubric from your own work, not the leaderboard.

WHAT TO LEARN

A repeatable, five-number personal rubric run against tasks mined from your own chat history tells you more about whether a new model is worth switching to than any public benchmark score ever will.

01The weekly model-drop ritual

Public benchmark tests (coding arenas, math olympiads) measure a population of tasks that barely overlaps with everyday work like emails, audits, and reports.
A parody cold open works as a hook because it names a shared frustration — repetitive, low-value tutorials — before pitching an alternative.

02The better way: benchmark your own work

A single command that replaces a repeated manual decision (which model to use) is a strong value proposition for a tool or skill.

04Mining chat history into real tasks

Mining a large existing archive (1,000+ saved conversations) into a reusable test pack turns a one-time analysis into a permanent, repeatable asset.

05Building your own rubric

Letting a model grade its own output introduces bias — any self-assessment system needs a rubric defined independently of the thing being judged.

08The live progress page

A live progress dashboard during a multi-minute automated process reduces the perceived wait, because the viewer can watch real work happen instead of a spinner.

10Reading a completed report

One tied result isn't a verdict; treat a single benchmark run as a data point, not a final decision, before switching tools.

11The five-dimension rubric explained

A five-dimension rubric (quality, instruction fidelity, tokens, speed, turns) captures tradeoffs a single score can't, since a chattier or slower model can still score well overall.

12Task-by-task results and verdicts

Reporting concrete outcomes ('9/10 checks passed', 'costs less, takes less time') is more persuasive than vague claims like 'better' or 'faster'.

13Grab the free skill and wrap-up

A free lead-magnet tool paired with a paid community is a straightforward way to convert viewers who want to go deeper than a single video can cover.

Glossary

Terms worth knowing.

Personal benchmark: A custom set of your own recurring tasks used to test whether a new AI model actually improves your specific work, instead of relying on public leaderboard scores.
Test pack: A reusable bundle of real, recurring tasks mined from a person's own chat history, used as the fixed input set for every future model comparison.
Instruction fidelity: A measure of how closely a model follows the exact instructions given, expressed as a percentage of directives it actually honored.
Effort level: A setting (such as low, medium, or high) on models like Claude that trades response depth and token cost for speed.
Slash command: A shortcut typed into an AI coding tool, such as /benchmark, that triggers a pre-built automated workflow instead of writing a fresh prompt each time.

Resources

Things they pointed at.

07:50tool/benchmark skill (free download) ↗

08:00productEarly AI-dopters community ↗

08:05linkPrompt Advisers (Mark's agency) ↗

Quotables

Lines you could clip.

00:00

“So let me know if this sounds familiar.”

direct-address cold open, universal AI-viewer pain point→ TikTok hook↗ Tweet quote

01:06

“Their benchmark never sampled your life.”

tight, quotable thesis line pulled straight from the on-screen title card→ IG reel cold open↗ Tweet quote

03:28

“You'll be able to compare Opus 4.8 to Opus five to Fable five to whatever brand new model comes out.”

concrete payoff statement, names the tools→ 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 let me know if this sounds familiar. You have a brand new model come out for the third time this week, and naturally, you go on YouTube, you close your eyes, and you open them, and all of a sudden, you have a 100 brand new tutorials. All of them structured in the exact same way.

Insert name of model is absolutely insane and changes everything. You then are lured to click on said tutorials. And then in the tutorial, you watch someone build a website you're never gonna use, build a three d game you're never gonna play, and create some form of app that wasn't on your to do list to begin with.

Sometimes you'll even see someone scroll through and read with you for the first time a new model's benchmarks as if those numbers tangibly mean something to the majority of your day to day work. There must be a better way. Right?

Right. In this video, my goal is to show you a way that you can run your own benchmarks for the actual work that you use so that when a brand new model comes out, you don't have to watch a tutorial.

You can just run a simple slash command that I will give to you by the end of the video and quickly know if this brand new model actually changes anything for you whatsoever, or if you should just park it on the side and focus on the stuff that actually matters. So if you're bored of the repetitive videos that you see every single week and you want something that actually moves the needle, then let's jump in.

So every single time a model drops, you get a series of benchmarks. The unfortunate thing is unlike the benchmarks in what they're testing for, like Web Dev Arena, Math Olympiad, SVG Unicorns, your actual work are a series of client emails, briefs, repo audits, health logs, lead lists, PowerPoint presentations, and things that are actually tangible.

So instead of relying on someone else to hopefully go over the very use case that applies to you, you can have something like Claude or Codex go through all of your chat histories in the past, isolate all the common tasks that you execute, and it can serve exactly how it was run and how it's executed by prior models and run those exact same tasks and projects with this brand new model.

So whether it's rewriting a cold email and testing that out on different effort levels or drafting some launch post, In my case, I have over a thousand conversations on my system. So almost two gigabytes worth of liquid gold in terms of information that I can feed to the AI so the AI can assess itself and test it against a rubric on how good it is against this cutting edge brand new model.

So how this works is you have AI scan your entire system for all the conversations you've had. And then in those conversations, you mine for core nuggets.

What are the core initiatives and tasks that you actually execute day to day? Because these are the very things that are worth testing with the brand new models. And these are the things they'll tell you, yes, it's worth paying more.

Or you know what? You could probably run this model on low effort and get the exact same benefit of running this other one on extra high. Then actually having an AI grade itself leads to a lot of bias.

So what you do is you create a rubric yourself on what you decide your benchmark to be. That could be based on vibe. It could be based on specific tasks, on the copywriting, whatever you want.

And the main idea here is once you create your own rubric for what your personal benchmarks are, that could be performance on those specific tasks as well as things like a vibe check on the verbosity of the model. How judgmental is the model? How sassy is it?

You get to create what the metrics that matter to you are. And then once you run this kind of skill, you'll be able to compare OPUS 4.8 to OPUS five to Fable five to whatever brand new model comes out, whether it's ClaudeCode, Codex, Kimi, you can keep evolving the skill as you want.

And like I'll show you in just a few moments with all of these open tabs, you'll be able to do something as simple as writing slash benchmark and then writing the command. So go compare OPUS 4.8 to OPUS five on medium and low effort.

You'll go do this audit for thirty to forty minutes, test it out, wrap it against your rubric, create the report, and tell you exactly what the overall verdict is.

So these are the three trials I'll walk you through. But just to show you how it works, you would just open a brand new terminal. We will log in to a brand new session.

And, again, you can make this work with whatever language model of choice, and you can do slash benchmark. There we go. And I would say compare Opus 4.8 on low to Opus five on low for copywriting based on what you know I care to create copy wise.

K? We'll send this over. It will then start compiling.

And then within a few minutes, it should start spawning a brand new live artifact. This live artifact will have a table. This table will show all the different elements that's gonna be testing over the next thirty, forty minutes, and it will report back in real time once it's completed them.

Then once it's ready, it will confirm with you if this is the exact task that you're trying to test. Assuming that it is, you can click run as is, and I can say three trials. Click submit.

And then the next step should be spawning this brand new page so I can keep track of all the trials. And there you go. It spins up a brand new web page that opens for me in my Chrome browser, and it's working on the very first row, which is the very first test.

And both are in progress, and it tells you that both are running on low mode. So you know it's running at the right effort level. Now instead of making you wait for forty minutes, I'm gonna go through the completed runs and show you the prompts that I sent over.

So this one is slash benchmark Opus five versus Fable five on just the executive email triage task. So pretty much email copywriting test.

Now the next trial was running Opus on low and high as well as Fable on low and high on a particular task. And trial number three was pretty much the same thing where I said OPUS five at low effort versus OPUS five at high effort, three trials, and I made it generic. So it's kind of dealer's choice on what tasks they would choose.

So this is an example of a completed report, and it tells you exactly what you're looking for, which is it tested the task, but it was dead even. Meaning, it's not worth it for you to switch your entire workflow to use said model outside of cost, assuming that it's head to head based on its effort levels. And this is an example of a completed report where we tested one particular task and it tells you exactly what you're looking for.

So it doesn't seem that it's worth it for me to switch from my fable low to my opus low or opus medium based on the results of this particular run. And as I scroll down, you'll see exactly what my personal rubric is. And if we pop over for some clarity, one is quality, the quality of the actual answer.

Now quality can be out of 10. You can give it some rubric like I did in terms of what quality means to you. And instruction fidelity, which is how likely is this model going to follow the exact instructions that I give it.

And then you have naturally token efficiency, speed, the the number of turns. So the more turns a model takes, the more tools it calls.

By proxy, the more context gets bloated and the more tokens you consume. So if you pop back over, you can see all of the different tasks that I give it.

It will tell me of what percentage of my total workload is said task, what was the prompt that was tested, and what were the results? What was the before and after? How many turns?

How many words? How many checks? Etcetera.

So it can go through the JSONL file that contains all the information, all the metadata from that run and tell you exactly what happened so you can make the final decision. And just to show you a few other examples, this one says Opus five talks like a person and works faster, but it missed this particular brief. If you go to the next one, skip the pricier Claude Opus high, Fable low quietly wins.

So as you scroll through, you'll be able to see exactly all the benchmarks for every single effort level, the total time it took, and all of the postmortem reports because your goal is clarity. So instead of spending your time constantly feeling confused and lost and looking at all of these headlines with people bickering that this model destroyed this model or this thing killed this brand new industry, you get to be the judge and the one in the driver's seat.

And that's really it. So all you have to do is grab the skill that I made for you completely for free in the second link down below, and then you can tailor it to the models of choice. You can change the rubric, whatever you need to get the clarity you're looking for.

And as always, if you're seeking a hype free environment to get a constant stream of exclusive content and resources that I put out all the time, including our Claude Code and Codex Living course, then check out the first thing down below and join me in my early AI adopters community. And for the rest of you, if you found this helpful, if you found this a breath of fresh air compared to the repetitive tutorials you watch all the time, I'd super appreciate a like and comment on the video.

Alright. I'll see you in the next one.

The Hook

The bait, then the rug-pull.

Every time a new model drops, YouTube floods with the same 100 tutorials — someone building a website you'll never use and reading benchmark numbers as if they mean something for your actual work. This video swaps that ritual for a personal benchmark built from your own chat history.

Frameworks

Named ideas worth stealing.

06:07list

The five-dimension personal rubric

Quality
Instruction fidelity
Tokens used
Speed
Turns

A scoring rubric a viewer writes for themselves so model comparisons aren't judged on a single vague impression, and so the AI isn't grading its own work.

Steal forany recurring AI-tool-choice decision (which model, which effort level, which vendor)

02:40model

Personal benchmark workflow

Mine your chat history into a test pack
Write your own rubric for what 'better' means
Run /benchmark to replay real tasks against the new model
Read the report and decide

The four-step loop that replaces watching a tutorial every time a new model launches.

Steal fordeciding whether any new AI tool or model release is worth adopting

CTA Breakdown

How they asked for the click.

VERBAL ASK

07:50link

“Grab the skill for free (link in the description)”

Soft CTA delivered as a lower-third over the talking-head close, paired with a pitch for the paid Early AI-dopters community, then a standard like/comment ask on the final frame.

MENTIONED ON CAMERA

07:50tool/benchmark skill (free download) ↗

08:00productEarly AI-dopters community ↗

08:05linkPrompt Advisers (Mark's agency) ↗

FROM THE DESCRIPTION

PRIMARY CTAWhere the creator wants you to go next.

OTHER LINKSAlso linked in the description.