GPT5-6 was released by OpenAI, and it is

a great model. But, even better than it

being a great model, I think it takes us

out of the turn-by-turn work with AI.

What I mean is I think we're seeing a

brand new bend in the curve. We're

seeing one of those transformation

points where we start using AI in a

truly different way because of the

capabilities that have been given to us

with this kind of incremental increase

that we're seeing. I want to go through

what GPT5-6 is, how strong it is, the

three different variants, Luna, Terra,

and Sol, how they compare against

something like Fable or even Sonnet, so

that you kind of understand where it

fits and which one you might use, and

whether or not you should even be

interested in it. But, I really do also

want to cover what it means, I think,

going forward. This is a truly important

moment, I believe. These models, Fable

and 5-6, these are really that moment

where we're saying, "We have new

capabilities. We don't know how to use

them yet, and they're a little bit raw,

but they're going to give us something

brand new." So, we're going to go

through and build this. I'm going to

kick this all off with something really

kind of fun that I haven't even done

yet, so we'll see how it works out.

We're going to kick off a new request

against Fable and GPT5-6 Sol to see who

can build the best version of this

application, or not even best, just see

what both of them come up with with one

big build. We'll let that cook the whole

time we're going through the video, and

then we'll take a look at it at the end.

I hope. In any case, let's dive right

in. Okay, so very quickly, I'm going to

show you I'm in the Codex application

right now. For now, what I'm going to do

is I'm going to put in a new request

here. This really is pointing at a file

that's inside of this repo that we're

in. I'm also putting it in the work

tree. So, what I'm going to do is kick

that off, and this is using uh 5-6 Sol

extra high. So, this is GPT5-6. Okay.

So, I'm also going to do this in Claude

Code against Fable 5 extra high, and get

both of those kicked off and running

while we're sitting here doing this

video. So, let's dive into what they

released or what they announced with 5

6. All right, I'm giving myself only

about a minute maybe a minute and a half

to talk about this. GPT 5 6 has

released. There are three different

sizes. There is Saul, the big one.

That's the big big one. Terra, which is

the middle-sized model. And Luna, which

is the smallest model of them all. They

of course kind of degrade in their costs

in that same kind of way. Luna is much

cheaper than Saul. Okay, better better

faster faster cool neat very capable

faster cheaper better better better at

following instructions. Okay, and to

round it out. I know I know it's crazy.

It's the same thing every single time.

We'll do a little bit of measurement in

a second so you can see what it's done.

I want to point out though Saul, the big

one, is a 530. And that's kind of $5 per

million input 34 million token output.

And Terra is a 2 and 1/2 15. And Luna is

a 1 6. I would definitely take a look at

Luna. I wouldn't normally say that, but

it's a cheap enough model and even Terra

is measured at a price cost here. 2 and

1/2 and 15 is roughly the Sonnet price

cost. So, it's really interesting to

compare Terra against Sonnet. And Terra

really kind of outpaces Sonnet in all of

these charts in a major way. So, that

cost is kind of interesting. Okay, let's

briefly go through my own benchmark. I

run a benchmark. I say this every single

time. I give it a big request that has

like a hundred items in the request and

I also really put in some meaningful

details that are not necessarily

requested items, but uh durable intent.

The reasons I would need these things to

be the way that they're being requested.

And so, on the x-axis is the item

itself. I asked for a button. Is button

in the final plan? Not necessarily after

it's built just just the first step. So,

this is does it survive first impact? On

the y-axis is kind of does my intent,

the reason, survive the plan? So, what

we'll see this is the previous

information. Here was GPT-5.5, previous

model, Opus-4.8, pretty close to it, and

Fable-5 hanging up here. So, Fable-5

really did a great job. Let's come in

here and add some of the new models. If

we look at Luna, you'll see where Luna

hangs out. Really fantastic. Great on

planning, not bad on uh intent recovery.

So, the Y is still a little bit low,

quite honestly, but it is a much, much

smaller model. And remember, Sonnet down

here, Sonnet-5, the brand new Sonnet

that released, is hanging out

languishing way down here on my chart.

So, let's take a look at the Tera model,

which is supposed to compare, and you'll

see Tera way up here. So, Tera is doing

a great job, quite frankly, at uh

basically maxing. We're at 81.4%. This

is the highest that I've seen for making

the passing the intent through, being

aware of the intent. And this is three

runs for each one of these models at

different levels, and I think these are

all extra high for each one of these.

So, it's really worth saying this is a

fantastic model. And the last big one

that we're all wondering about, which is

the big behemoth, Saul. How did Saul do?

Saul is sitting right in here. So, let

me zoom in a little bit so that we can

see the family that we're dealing with.

Saul, GPT-5.5, and then Fable-5. So,

Saul and Fable-5 have roughly the same

intent recovery, but Saul doesn't have

as much planning recovery. But then,

we're really only talking about a point

here, and I on any given one of these

axes, if I'm if I'm really talking about

anything less than a point, I would say

my fidelity is probably not tight enough

to care about that. So, that cluster

Saul very close to Opus and Fable,

Opus-4.8. So, really, really great

performance. Let's see how they do.

Okay, first, let's check in on what

everybody's working on in the the big

prompt that we put in, the game that

we're asking each one of them to build.

You can see um Saul and all of the GPT

models, including uh ChatGPT, which is

now what we call Codex Desktop, Chat GPT

Desktop, uh which has work and Codex

inside of it. Like I said, different

different video for that. Actually does

computer use and evaluates the the

browser itself. It actually has a

browser integrated over here that we

would be able to see it if we were

looking at it over here. So, this is

actually what it's showing us a picture

of and it's running through the system

right there. Same thing over here for

where Opus or where Fable is, we can

open the browser and see if they they

have not yet taken over to use the

browser to take a look. I'm going to

guess that they're not actually working

on the UI of it just yet. Fable so far

is at 137,000

tokens and Saul is at 120,000 tokens.

So, really really equitable. Let's let

those cook. Now, let's go take a look at

the Saul model and the others and how

they built a previous application design

that I've put together so that you can

really see apples-to-apples comparisons.

Okay, so I have an application that I

get new models to kind of build and it's

a native application that has a bunch of

design assets, both images as well as

true design systems and assets inside of

it that should describe the application

itself. I will show you the finished

product in a second so that you kind of

understand the fidelity that we're going

for and then what I'm going to do is

take you through the builds of each one

of the models, showing you what's best

about each one of those models. What's

probably important to understand very

simply is this is a native application.

So, it's kind of highly performant. It

uses kind of advanced techniques for

dealing with animations and blends and a

bunch of things like that. But, that

isn't something that's going to be super

easy to understand through a simple

video like this. But, what I'll show you

is what really is good for some of the

models and really a distinction with the

exact same model, a better way to get

better results or at least in my

experience. All right, let's just take a

look. Okay, so let's kick off the video

for Luna, and you can see it will launch

the application and do a circle around

the outside ring, and then a circle

around the inside ring. It is pretty

complete. I will pause it here so that

we can see what the application looks

like. The lines are clean. It has all of

the all of the circular parts to it.

This is a great start. Next one, let's

dive into Terra. Same concept, do a ring

around the outside, and then around the

inside.

And you can see none of the animations

are in place. Let me show you what the

application

should actually look like. So, this ring

here is Terra, and if I bring up the

actual application as built, this is an

application that I finished out. So,

this is not the first single shot

experience that I got back, but this is

from Fable, I think extra high gold. So,

a while ago I built this using Fable,

and it got me very very close to this.

And if I go around the outside, you'll

notice the smooth animations between

each one of the movements. And then the

same thing with the inside, you can see

some of the moving icons as they jump

around from position to position, as

well as the elegant movement between all

of the the rings and the selections. So,

that's what we're really looking for

here, and certainly not what we're

seeing when we look at the build of

Terra. You can see it's just popping

around the outside, it's popping around

the inside, and even worse, it's worth

pointing out that the bays or the

sections are not centered on the icon.

So, this icon should be inside of this

bay, or moreover, the selection and the

lines on the graph itself that you might

not be able to see on this the dial

itself are going through the center of

the items instead of the center of them

as bays. And okay, so that was the small

and the medium. Obviously, what we have

to do next, let's take a look at the

large. We will start here.

None of the GPT-56 models had any of the

animations that were necessary. And

that's curious because all of the Fable

and Opus models did have this. Unlike

these GPT-56, they did deal with the

animations between the different

elements. So, I would say the winner out

of all of these is all of them or kind

of

sort of none of them. None of them are

terrible. Okay, and let's round this out

quickly by showing you one of the things

that's really different. So, when I do

56 soul,

but I use the exact same prompt that I

asked for the first one to be built and

instead use {slash} goal in front of it.

So, I set this up as just a goal with

the exact same request that I was giving

the others. This is the outcome. And

this already, you can see very quickly,

has a much better better design style to

it. Simple, light, straight lines

between everything. Really good job. So,

this is a huge step forward. And all I

added with {slash} goal. And this is

something that I want to call out. This

{slash} goal concept is very, very

strong and it's worth you giving it a

shot in some of your builds. If you're

not quite getting the results you want

or you're always finding that you have

to push back in a couple times to get it

closer to what you asked for, the

{slash} goal, I find in both this and

Fable and all of the other models that

I've tested, always seems to perform a

little bit better or very, very

frequently at least. Okay, and so when I

talk about {slash} goal, the one thing

that might come to mind, and I think it

does for a lot of people, is if I'm

going to do {slash} goal, what is that

going to do to my token count? So, as

you might see up here is soul itself.

The Soul straight is what I call it.

Took 31 minutes. Soul with goal took 28

minutes. So, 3 minutes less and 700,000

tokens versus 550,000 tokens.

That's a big difference. And the goal is

both faster and fewer tokens. Taking a

look at Here is Fable, Fable 5, and

Fable 5 gold. So, you can see Fable 5

took 27 minutes. Fable 5 gold took 48

minutes. So, just putting gold on Fable

exploded it. Now, again, these are

non-deterministic, so it would probably

build at different times. If I had built

this three or four times each, I'd get

better numbers. These are single-shot

definitions. The build is only done

once, to be fair. So, you have to kind

of grain of salt this and kind of take

this with a trend line. And the one that

I would call out is this is the one we

were just looking at. And this is the

one that you've heard about the release.

So, this is GPT-56 Soul. It's the big

new GPT model.

When you put gold in and it got much

better, remember it got markedly better,

it's both

faster, so it took 28 minutes instead of

31 minutes, as we noticed, and it's also

using less tokens. And that's what we

noticed. That does not hold across the

board. The 5-6 Terra gold here took a

little bit longer and used more tokens

than the 5-6 Terra here, but it did,

once again, have a better

representation. So, it's really worth

saying /gold is not what you think it

is. It is not an absolute token burner

that will do 5-10 times the amount of

tokens that you're currently using. I

have not experienced this. I will say,

it is worth saying, the Fable here,

where it took 280,000 tokens, it only

did it for 28 minutes and was not a very

good fidelity. In fact, this is the one

that things didn't line up. It was

actually the only build that I have

that's kind of broken. And but the five

the fable five goal one it is the one

that I ended up pushing forward because

it was so good. Now, it took twice as

long and we can say it took twice as

many tokens roughly. I would say it did

what the fable five initial straight

build should have done in the first

place. But in any case, {slash} goal, I

really find it to be tremendously useful

for the reasons of how goal works, what

it's really all about. And goal is just

basically saying check your work at the

end. If you're not finished, keep going.

That's making it a little bit simpler

than it really is, but that's basically

the concept is it creates a loop out of

self-evaluating whether or not it is has

reached the goal that it should stop at.

So, okay. I know you all can't hear

that, but

there is some music going on. So, I have

a feeling one of our video games is

done.

We got to go take a look at those. Okay.

[laughter]

So, here we are. This is what we were

building is a battleship kind of clone

game. And this is Claude Code's build of

it.

This is pretty awesome.

And get to my battle stations.

All right, and it's my turn. I have 41

seconds. Looks great. I'll attack there.

I missed.

Oh, yeah.

Oh.

Oh, come on.

Oh,

>> [laughter]

>> wait. Wait. Who the heck am I playing?

All right. How about here?

Yeah, you missed me, buddy.

Oh, yeah. You're dead now. You're dead.

Here we go.

Oh, and it just stopped. Not sure why it

just stopped. Might be reloading.

Hard to really tell, but I think it's

complete. So, let's close that.

It is still thinking. So, I did open it

in the middle of its still working.

That's damn good for still working.

Okay, let's take a look at Codex's.

So, this one would be the Sol build

first run. Let's take a look at what

first run looks like for the Sol build.

All right, I come in

two commanders. Oh, wow, have you done

person versus person already? That's

kind of awesome. I'm going to do

algorithmic. Yes, let's do algorithmic.

At position overlaps.

How do you rotate? R.

Well,

interesting. So, I can't seemingly move

the ships after we've put them in.

What if I rotate? Yeah.

Okay.

And a destroyer.

I can't even get back to the back row.

Okay.

So,

maybe not perfect yet.

No sound effects. The other one did a

great job with sound effects.

Very difficult to tell

that I'm hitting or missing.

So, I would say not bad. It's It's

definitely interesting. Okay, I'd say

it's fine.

>> [music]

>> Awesome, it's even testing the computer

Actually, in this case it's computer

against AI and even AI was taking too

long, so it's trying to evaluate why AI

is taking so long to make its turns.

I mean, really fantastic. Even the test

cases here are kind of fantastic to

watch.

All right, I want to talk to you about

the four

uh elbows that I've seen in AI and what

I mean by kind of AI 2.0. So, what we

saw about 2 and 1/2 years ago was being

able to code with these systems very

meaningful. Maybe maybe three three

years ago, uh being able to code

meaningfully. We had tab to complete

another things like that for a while

that you might be able to finish a line

or fill in the variable that is closest

to your line, those kinds of things.

Those were great, but it wasn't quite

the same as being able to go to chat GPT

and ask for a function and it gives you

gives you kind of the whole function

back and you drop it into your code and

then adjust it. It was absolutely not

finished, it was not perfect by any

stretch of the imagination, but it

meaningfully could move you forward and

scale you a little bit. That was kind of

really useful. And then about a year and

a half ago, a little bit more than that,

uh Codex was the really the first one

that cracked the harness to be able to

do kind of agentic file editing. So, it

could all of the sudden magically create

the file. When you said, "I need this

new function." or "I need this new

class." it would actually go to write a

whole new file for you. And I understand

today, that's not all that fascinating,

but back then it was mind-blowing to

watch it create files. Not to mention go

to files you had and edit the correct

lines in a file. That was magical. So,

that was the second elbow and it

tremendously changed the way that we

worked with it such that if you were

still copying and pasting code from chat

GPT or something like that, which a lot

of people still were for quite a while,

you were actually doing it wrong and you

weren't scaling like you should. All

right. Then we get to kind of the end of

last year, in the November time frame,

where we started understanding these

things were now agentically working,

creating files, things like this. But we

were pretty much still stuck giving it

small sets of requirements. I could give

it four, five, 10 requirements at the

most together. It would lose some of

those. That's part of my planning

benchmark. That's uh before that was

period where I started that. How much

planning, how many items are actually

making it through the planning phase.

That's why it existed.

So, we came up with policies and

practices of how you might put together

different kind of request buyers files.

This was the time we started with PRDs,

spec-driven development, those kinds of

things, to-do lists, all of this. Those

substantially helped. Those were very,

very meaningful that you could then put

in requests that were 20 or 30 kind of

items. And around November last year, we

started noticing you could put in 100

items. Now, my planning benchmark was

showing back then 60% of the items were

making it through. Um maybe 70% at that

point, but still that was substantial

compared to the days just previous, a

couple months previous to that where we

were doing two or three items or 10

items and usually getting it right. All

right. Then, fast track forward to now.

I think we're at another one of those

elbows. It's been a little bit longer,

maybe I'm not really sure what date we

describe to this, but I think these

models bring us to what I might describe

as AI 2.0. This is that moment that we

are no longer asking for kind of

task-level work. We can now ask for

objective-level work. And you've seen

slash goals, you've seen workflows,

you've seen fan out, you've seen a lot

of mechanisms these days inside of these

harnesses, directly available for you to

be able to ask for much bigger work,

much broader work than just the tasks

themselves.

Indeed, the thing we just did with

Battleship, I did not describe any of

the individual tasks. In there, I was

describing the basic outlay of a

Battleship game. I didn't even really

describe Battleship, of course, but that

would be a pretty known target. And I

was just saying, I want a 3D game that

fits this feeling and should be

highly animated and you can very clearly

see what is the opponent doing and

thinking. All of these kinds of things.

Really, it was much more intent-driven

and objective-driven than it was

feature-level driven. That is actually a

change. And I understand this is just a

single piece of software, so it's it

doesn't quite stretch it as far as we

actually can go right now. I go much

further than this in a lot of my

experimentation. My experimentation, I'm

several levels above that at this point.

It doesn't work all that well yet. It

does work, but you have to do a lot of

work to make it work. This would be the

copy and paste day. So, we're getting

there, but the models are making a

substantial change. So, I think what

we're actually seeing, better model,

sure, better better faster faster

cheaper cheaper. Maybe not cheaper

cheaper. Yes, that is something that

we're seeing right now, but in reality,

what I think we're seeing is this is a

moment that we will look back at very

much like we did in the Opus planning

phase with PRDs and the cursor days with

agentic writing and chat GPT being able

to write

kind of meaningful code that we would be

able to copy and paste. All of those are

very very meaningful moments. I think

we've just seen another one. It's raw.

It's the beginning, but I would say it's

your chance to start diving in and

understanding how that works. These

models are really capable of offering

that to us. All right, enough of this. I

hope you saw something that was

interesting, at least. My final takeaway

of all of this would probably be

Uh, saw Battleship, right? You got to

see it with your own eyes. At the same

time, Battleship built by Fable far

better far superior than it was using um

the GPT models, the new 5 6 GPT models.

GPT 5 6 was great. It worked very very

well.

But, to be fair, it was maybe a half of

the time or now a third of the time. So,

Fable for the win still. I have to say

Fable for the win.

But, admittedly,

three times longer is actually three

times longer. All right. I hope any of

this helped in any way. Good luck out

there moving up to kind of

objective-based requesting cuz 2.0 is

here. We're really moving forward into

the new world of AI, especially from a

development or kind of a a work

standpoint where we don't have to say,

"Go to my email client, search for these

five things, bring back the in" That

would be task level. You being able to

objectively say, "I want emails from my

boss." That's objective level. It will

figure out the details. So, kind of

start working on that space if you can.

You'll be surprised at how much better

these things have gotten in that space.

All right. Thanks for coming along for

the ride on this one, and I'll see you

in the next one.