In my previous video, I had Fable build

a completely polished system, a game of

spades, that went all the way from a

very clear design document to a

completely polished deliverable

application. That video really goes

through how I did all of that. Once I

got there and it was so good, I thought,

"Why I wonder if Soul can do the same

thing?" So, this video is kind of an

investigation into can the GPT-5 6 Soul

model do almost the exact same steps

with a different application to be fair,

but very, very similar. And actually,

the finding that I came up with was

entirely surprising to me. This is not

what I thought the outcome would be, so

it's worth taking a look. But, what

you'll really find here is should you

use Fable? Should you use Soul? Are they

completely interoperable with one

another? Are they kind of hot swappable

and it doesn't matter? Or does it

really, really matter? And let me tell

you, to me, it really, really matters.

So, let's dive in and I'll show you

exactly what we're going to go through.

Okay, wait a second. One very quick note

here before we dive in. I want to make

this very clear up front. One

application that we built was spades.

The next one that we built was

Parcheesi. If you don't know the

Parcheesi game, you'll be introduced to

it very quickly here. It's a little bit

more complicated. It is not 10 times

more complicated. It is not two times

more complicated to build, but it is a

bit more complicated. There's some more

moving parts to it. So, that exists and

what we asked Soul to do was, quite

frankly, more difficult than what we

asked Fable to do and we would

anticipate the results would match that.

They do match that, but they kind of

over match that. You'll see in a second.

I just wanted to call that out. Okay, as

I mentioned, I have a previous video

that goes through all of the how here.

So, if you're looking for exactly how I

got to the results that we're showing

here, go watch that other video. But,

what I'll show you here is I used Claude

design and you can see here this is just

claude.ai/design.

You can use this with your subscription.

Um if we look back at the designed game

for what we did with Fable, this was a

spades game. Here's the design, a bunch

of different screens and how they work,

some of the animations, that kind of

stuff. So, that was for one of the

applications. What we did for the Soul

model was give it a version of basically

ask it to design a version of something

like a Parcheesi game. So, if you've

ever played Parcheesi, there's four

players around a board, they have to

move through a certain series of of

squares as you roll dice and move pawns

between those. What we did with this is

very much like the last time, we shared

this, we download the zip, this zip file

is going into Codex. I'll show you

exactly how I did that next, but first,

I need to show you an intermediate file.

This is the design. This is what it

looks like. This is not what it is, and

I want to make that very clear. So, I

then described what it is in the next

file. Okay, next step, really simply,

this is the application. This folder was

empty when I started. What we just

downloaded from Claude design, I would

have created the docs folder and created

the design folder, and then I dropped

that file right here. So, that was the

zip that we would have just downloaded,

right? That's the first thing. This

information comes out of here once it

explodes, but we asked Codex to do that.

The only other file is this request

file, and this file is something that I

basically I'm telling the building

agent, you're building a system that is

going to be multi-user, you need to use

uh kind of peer-to-peer solutions to

pull this off to kind of uh create that

paired relationship. It's also a video

game, it's mobile first, you definitely

need to take into consideration mobile

experiences, but it should also work on

these other platforms, et cetera, et

cetera. This is the exact same kind of

information. This file, in fact,

essentially came from the one that we

gave Fable with Spades. So, it's

basically the same thing. And from here,

the only thing that I did was came out

to Codex and I said, "Set up a goal. Use

the game build request file that we just

dropped into that folder there." Um and

build until complete because all of the

instructions are in there, including the

information about the handoff design

file. So, it was all in that one place.

This is also the same basic prompt that

I gave to to Claude code previously to

get the build done when I was building

with Fable. That's it. They are

otherwise really the same. Okay, and

from here, let's take a look at what

they came out with. I want to point out

though at this moment, this is not

necessarily where that first build got

us. I have pushed back into these a

little bit after that, and I'll describe

that in a second because it's kind of

the most important thing about what

we're talking about here, but I did want

to show you this is the Spades game. If

you come in and play this Spades game,

like any other Spades game, you get to

bid, you get to

play your cards.

Hey, I even get to take one. Fantastic.

So, it's a normal Spades game. You can

come in here if I leave the table and

host my own game, it allows me to

connect with a code. Normal kind of

stuff that you might expect from a

Spades game. The other side is what we

just built with GPT-56 Soul. So, this is

Dash. It renamed it Dash really in in

fact, the design step renamed it Dash

instead of Parcheesi, but if we play

here, then we can come in, play a game,

pick the different uh characters that we

want to play against,

pick the character that we're interested

in,

and then play the game. And so, we're

down here in the left, and we get to

roll first,

of course.

And we have to get a five to get out.

So, you'll see the different turns for

the different players. He rolled a five,

he gets one of his pieces out. So, this

is the way it works. You work around the

board. There's different cards for

different power-ups, those kinds of

things in the game.

There's a lot of moving parts here. Now,

again, this is not the finished version

of the game or this wasn't that first

build. This is closer to where the

multiple push-ins got us, but

it was very close to this. It was It was

reasonably close to this experience. And

so, from this is what I kind of want to

describe. What happened after we got

that first return? And what How long did

it take to get just to that? Okay, so

it's worth saying both of these took

about an hour and a half to complete.

So, they took about the same amount of

time.

Remembering, of course, that the Soul

job was particularly more difficult than

Spades. Now, Spades is not a very, very

simple thing to build, but at the same

time, it's relatively static. As you saw

all the movement in in the the Parcheesi

board that we have. So, if they both

took an hour and a half, what did I end

up with? Okay.

The pass that I got back from Spades was

excellent. And what I did from there is

I started playing the game. And I did

this for both of these products, quite

frankly. Started playing the game. I

opened a microphone. And every time I

saw something I didn't like, I took a

screenshot and put it into a folder. And

so, then I had the ability of just

saying, "Here's the 12 screenshots or

whatever it was." And while I was

playing through the game, I was speaking

out the things that I didn't quite like

or I didn't understand or maybe could

use a little bit of adjustment. So,

there was basically one intent file and

10 or 12 screenshots in a folder. That

folder, of course, was inside of the

project folder itself for Spades. And I

could go back to the agent at that

point, it was Fable, and say, "Look, go

take a look at my notes and the

screenshots that I need fixed. Create a

goal around doing this work and making

sure that it's that it's correct."

Again, you can see that I'm using goal

to do this kind of objective level work

that I'm not describing each particular

element. And I'm being very high-level

about the things that I'm looking for.

I'm not being extremely particular

unless something really particular

needed to be fixed. I did this for both.

I want to make sure that I make that

very clear. Both of them got this second

run. So, they gave me all the work back

in an hour and a half. I said, "Here's

the 10 things that I noticed that I

really just kind of don't like." And

then it got to work for another hour,

hour and a half on each one of them at

least, something like that. And so, they

both had a big first round update. And

after that, I only had a few adjustments

for Spades, and that was where I was.

And what you saw is relatively close to

that. I have pushed in a few more times,

but not enough to really talk about.

The other one, however, the one we're

talking about now, Saul,

that's the question. And so, just saying

both of these, how did they turn out a

single version of this build?

Brilliant, fantastic, great work, both

of them. I want to make that very, very

clear. But, I will say what I got back

from Saul, there were things that didn't

quite really work. So, things were

overlapping one another. Um there were

some rules that flat out were invented,

and I had to ask about where these rules

came from, and it said, "Well, it just

decided that this would be a good rule,

basically. It'll revert it back to the

traditional rules." That became a little

more expensive than I wanted. But, on

top of that, it also had like user

experience problems. Like characters or

messages or information was over the top

of the board in a way that while I was

trying to take my turn, I couldn't click

on the squares that I needed to click on

to move my pawns around. And that's

devastating, right? That to me is a

complete failure in understanding how

the game itself operates rather than

technically does it operate. And it's

kind of that that I think separates

these two models. So, I want to talk

about the investment that it took

for me using both these systems, giving

them this remit with a good design and

kind of that that instruction file of

doing a multiplayer game, this kind of

stuff. That worked really well, and

getting to the 1 and 1/2 hour mark

worked really, really well. In fact,

getting to about the 3-hour mark, maybe

3 and 1/2 hour mark, when we had pushed

in all of those extra things inside of

the folder that are the screenshots and

the big thoughts that we had. That

actually worked quite well.

But, not well enough. So, at that point,

I had done the initial request, I had

done that secondary larger request uh uh

or update request for Fable, and then I

did about two more, maybe a few more

than that. That's about it. So, I would

say maybe up to six, seven requests,

something like that, to get all of Fable

built, all of Spades built.

Okay.

At that point, though, it got to really

roughly what you just saw.

The other one, however, I did the same

exact kind of work. 3 and 1/2 hours in,

it got to a pretty completed state, but

still had huge amounts of little pieces

that I needed to go and clean up and

find myself. And what happened at that

point was very different. And this is

the big problem that I wanted to point

out. All right. So, this is pretty

simple to describe. As mentioned, we had

done a certain amount of work, put some

some requests in that were similar,

gotten to about the 3-hour mark, and

both of these were working extremely

well. In fact, getting to that 3-hour

mark is really roughly what you saw with

the Fable build, with Spades. It is

basically that now. I did ask for a few

more things, but that's it.

The other one, however, got to a place

to where there were quite a few things

that I still needed to push on. And

things that I couldn't avoid, as I

mentioned before. We just had to get

those cleaned up, or it was not a

completed product. It was still

excellent, but it wasn't complete. And

that started a round of kind of vibe

coding with it. I would put in kind of

generalized messages saying, "Here's the

kinds of things I need you to worry

about. I need you to take a look at

making sure that this is uh performative

on touch hardware. Right now, the

touches aren't capable because of XYZ.

So, I was being kind of directive, but

at the same time allowing it to work at

the goal level, and it would solve that

problem, and then it would solve the

next problem, and the next problem, but

never tack them together and kind of do

a reinvestigation. Now, it did hours and

hours of work and testing on some of

these to make sure it got it right. So,

it works exceptionally well,

but it just doesn't tack it together,

and it really needed me. What's

important to understand here is the

whole crux of what I'm talking about.

The first one,

working with Fable, I did basically six

or seven messages all told. I told it

six or seven things, and you saw how

small some of those requests were. They

really were not that big.

The second one, though, working with

with Soul and GPT-56,

I did 65 plus messages. And the first

three or four you've already seen. And

then I had to sit there for hours and

work with it, then it would go away and

work for several hours and come back. In

the end, the run time was incredible.

So, the first one was done in about 3

and 1/2 hours, and the next one was done

in about 14 hours. And this is work

time. The So, we're removing all of the

wait time or delay time for when it took

me time to get back, and it was asking

me questions. So, this essentially took

me several days to build, which is crazy

comparatively. So, all I can say is did

the the Soul model solve the problem?

Absolutely. Had I told it about all of

those considerations up front and been

very predictive about, "Oh, you you need

to make sure that you handle all of the

controls for touch controls, and you

need to make sure that when you make

communications between multiple players,

these kinds of things happens a lot lot

lot You know, these If I told it all of

that, I have no doubt it would have

worked." That's back to the kind of the

PRD days. Make sure you mention

everything that you needed it to know

about that it needs to address,

but that is not where we are today. The

Fable model did not require that. So,

what I would say is working in this

space is kind of a user-facing

application and this happened to be a

game, but basically a user-facing

application,

the Soul model needed me. I had to be

there. I could not get it off of my

back. The other one, Fable, more than

happy to run off, make some decisions,

and push forward, and turned out

excellent product. That's all there is

to it. If I was doing another project

similar to this, I would hands down,

without question, choose Fable right

now. Maybe GPT has another one coming or

there's some changes in their next dot

release. We're still at 4.6, not really

five for them, so maybe that's the big

change, but right now, I would say for

this kind of project, honestly, it's not

close. The fidelity in the end is

definitely close,

but it took so much of my work to get

there that

boy, I wouldn't say they're even at all.

I hope you found some value out of this.

Thanks for coming along for the ride on

this one, and I'll see you in the next

one.