[00:00] (0.24s)
Many people think that claude code is
[00:02] (2.40s)
better than cursor. So I brought on an
[00:04] (4.24s)
AI coding legend, Khan Zang, to see if
[00:07] (7.44s)
Claude code can actually vibe code full
[00:10] (10.08s)
application. And so to test this in one
[00:12] (12.40s)
sitting, Khan is going to try and build
[00:14] (14.96s)
lovable with Claude Code. In this video,
[00:17] (17.76s)
we show you how to set up Claude Code.
[00:19] (19.60s)
We talk about how you can build Claude
[00:21] (21.52s)
Code wrappers with their SDK. And by the
[00:24] (24.40s)
end of the video, you will see if we're
[00:26] (26.24s)
successful in building lovable with
[00:28] (28.32s)
Claude Code. And this thing also just
[00:30] (30.16s)
finished generating a website. Bro, ours
[00:33] (33.04s)
looks better. So cool. I'm super
[00:35] (35.60s)
excited.
[00:36] (36.32s)
This was a fun one. Let's dive in. So,
[00:40] (40.08s)
Khan, what are we doing today?
[00:42] (42.32s)
Today, we're going to be building a
[00:44] (44.08s)
website that builds websites with Claude
[00:47] (47.60s)
Code SDK using Cloud Code.
[00:53] (53.20s)
it's tough to wrap my head around this.
[00:54] (54.96s)
Do you want to like maybe break that
[00:56] (56.40s)
down just a little bit for those who are
[00:58] (58.56s)
like vibe coder native?
[01:00] (60.56s)
Yeah, sure. So, claude code is a tool
[01:04] (64.16s)
that lives in your command line
[01:05] (65.60s)
interface also known as CLI. It's this
[01:08] (68.08s)
big scary black box normally near the
[01:10] (70.24s)
bottom of cursor and it also exists
[01:12] (72.00s)
separately as like a terminal. It's the
[01:14] (74.00s)
same thing and it lives in the terminal
[01:16] (76.00s)
basically. And so this is a software
[01:17] (77.76s)
that Anthropic has released that uses
[01:19] (79.68s)
cloud to help you develop software like
[01:22] (82.56s)
kind of like cursor
[01:23] (83.52s)
like cursor and wind surf except it
[01:25] (85.60s)
lives in your terminal which makes it
[01:27] (87.04s)
different.
[01:27] (87.44s)
Yeah, it's a little more technical but I
[01:29] (89.52s)
also think it's a little more powerful
[01:31] (91.52s)
and the cool thing about it right like
[01:33] (93.28s)
anthropic released it for you to use as
[01:35] (95.60s)
a tool as a general consumer but they
[01:37] (97.76s)
also used it for you to use as a
[01:39] (99.84s)
developer. So I can develop tools that
[01:42] (102.00s)
use it as well. So like similar to the
[01:45] (105.76s)
way people are making money with chat
[01:47] (107.36s)
GBT rappers or like replicate rappers,
[01:49] (109.92s)
you can create a claude code wrapper
[01:52] (112.40s)
with something called an SDK.
[01:54] (114.48s)
Yeah. And so the way that kind of works
[01:56] (116.00s)
is like chat GPT is a very generalist
[01:58] (118.72s)
LLM like it can answer and do a variety
[02:01] (121.12s)
of things. Cloud code is definitely like
[02:03] (123.84s)
he's the nerd in the class. He's like,
[02:05] (125.04s)
"Oh, I'm only good at coding. I don't
[02:06] (126.32s)
care about anything else." but he does
[02:07] (127.76s)
coding really well you know and so you
[02:09] (129.68s)
can definitely build rappers around
[02:11] (131.04s)
cloud code but you'll definitely be in
[02:12] (132.96s)
the industry of like vibe code lovable
[02:15] (135.52s)
bault replet like you're going to be
[02:16] (136.88s)
building a codegen tool so if you wrap
[02:18] (138.96s)
cloud code it has great capabilities of
[02:20] (140.96s)
writing code but just know that the
[02:22] (142.64s)
products that you can make are kind of
[02:24] (144.00s)
limited in the scope that you're
[02:25] (145.60s)
probably going to be using it to write
[02:27] (147.28s)
right right I mean it is called cloud
[02:28] (148.80s)
code yeah yeah so today what you're
[02:30] (150.72s)
saying is we are going to use this new
[02:32] (152.56s)
tool cloud code to use the SDK of cloud
[02:36] (156.72s)
code which will power the app that we
[02:39] (159.28s)
create called Lovable. We're going to
[02:40] (160.80s)
create a Lovable clone powered by the
[02:42] (162.88s)
Yeah. Yeah. Yeah. A really a really
[02:44] (164.32s)
basic one. Yeah.
[02:45] (165.12s)
Let's do it. How do we get started? In
[02:47] (167.04s)
our last episode that I did with Mickey
[02:48] (168.88s)
where he broke down cloud code, he says
[02:50] (170.64s)
he uses it in cursor and so you do the
[02:52] (172.88s)
same usually, right?
[02:53] (173.84s)
Yeah. So, here's my experiment actually,
[02:55] (175.92s)
but we can just create straight up a new
[02:58] (178.32s)
So, we're starting a new fresh project
[03:00] (180.00s)
in cursor.
[03:01] (181.20s)
We're going to go ahead and create a
[03:02] (182.88s)
folder called lovable clone. Amazing.
[03:06] (186.88s)
Yeah, we're just going to go ahead and
[03:08] (188.32s)
open it. So now this is by the books a
[03:10] (190.32s)
very standard, you know, cursor code
[03:13] (193.76s)
development environment. I can create a
[03:16] (196.16s)
terminal by either doing this or using
[03:18] (198.24s)
the shortcut. And so I have a terminal
[03:21] (201.68s)
now and I can go ahead and run cloud
[03:23] (203.76s)
code like I did before in the terminal.
[03:26] (206.00s)
And it's asking to like read your stuff.
[03:29] (209.60s)
Sure, go ahead. And we can actually
[03:31] (211.44s)
configure this to do a lot of things
[03:33] (213.68s)
without asking. Normally you'll see
[03:35] (215.36s)
that. Oh, okay. No, I actually don't
[03:37] (217.60s)
want you to do anything. So, it's
[03:39] (219.28s)
already like trying to start coding. I
[03:41] (221.36s)
can tell it to stop.
[03:42] (222.32s)
It's eager.
[03:43] (223.04s)
Yeah, it found out that I wanted to make
[03:44] (224.56s)
a lovable clone because I named the
[03:47] (227.12s)
It just looked at the name of your file.
[03:49] (229.04s)
That's crazy.
[03:49] (229.52s)
And it started like telling you like,
[03:50] (230.88s)
"Oh, I'm going to set up a next.js
[03:52] (232.48s)
project with TypeScript. I'm going to
[03:54] (234.48s)
create a landing page. I'm going to
[03:55] (235.84s)
implement."
[03:56] (236.32s)
Cloud's like, "I don't need you."
[03:57] (237.84s)
Just gonna go through everything.
[03:58] (238.72s)
Honestly, it would be a super fun
[04:00] (240.80s)
experience to kind of see if it can do
[04:02] (242.64s)
it just right off the bat by itself. But
[04:04] (244.64s)
we have some custom demands. We want to
[04:06] (246.32s)
use cloud code SDK to go ahead and build
[04:10] (250.48s)
this whole thing. So there are a few
[04:12] (252.08s)
things that I guess I could show you
[04:14] (254.80s)
first. So like a shortcut that you can
[04:17] (257.52s)
do is you can actually do looking for it
[04:20] (260.56s)
on the keyboard.
[04:22] (262.72s)
This pound sign allows you to kind of
[04:24] (264.96s)
create like cloud MD files which access
[04:27] (267.76s)
persistent memory for your cla code
[04:29] (269.68s)
session. So I can say like I am building
[04:32] (272.88s)
a lovable clone but I want to use the
[04:39] (279.52s)
code SDK
[04:41] (281.76s)
and I can create that and it'll ask me
[04:43] (283.92s)
okay do I want it in my user memory or
[04:46] (286.32s)
my project memory. Well, user memory
[04:48] (288.96s)
would mean for every single instance I
[04:51] (291.04s)
use cloud code, it will try to think
[04:52] (292.56s)
that I'm building lovable, which is not
[04:54] (294.48s)
like the right thing. Yeah, that would
[04:56] (296.32s)
probably be more something like my name
[04:57] (297.44s)
is Khan, I could save that forever as my
[04:59] (299.52s)
user memory.
[05:00] (300.48s)
Project memory, this is where it belongs
[05:02] (302.40s)
because I am building a vibe coding a
[05:04] (304.16s)
lovable clone right now. So, I'll go
[05:05] (305.52s)
ahead and
[05:05] (305.92s)
So, I guess I guess if for those of who
[05:07] (307.28s)
have used cursor one, the bottom one
[05:09] (309.52s)
would have been like your cursor rules
[05:12] (312.00s)
and then the top one would be like a
[05:13] (313.76s)
readme file in that project.
[05:15] (315.44s)
Yeah. And as you can see, it's actually
[05:16] (316.80s)
very similar. Like Claude literally just
[05:18] (318.56s)
spun up a readme. Basically, an MD file
[05:21] (321.20s)
is a markdown file and it's basically an
[05:23] (323.20s)
upgraded txt file. So this is basically
[05:25] (325.20s)
a readme. And so it's it noted down. I'm
[05:28] (328.40s)
building a lovable clone. And so that's
[05:30] (330.24s)
really cool. Another quick feature I
[05:31] (331.76s)
wanted to showcase before we dive into
[05:34] (334.32s)
using it is you can shift tab to kind of
[05:37] (337.76s)
show autoedits on. So this is really
[05:40] (340.00s)
cool. And I can also shift tab again to
[05:42] (342.48s)
show plan mode. So, I guess I would
[05:44] (344.56s)
actually begin by saying I like do some
[05:46] (346.96s)
research on it because that's what I'm
[05:48] (348.80s)
going to do. And one really interesting
[05:50] (350.96s)
trick about Enthropics Cloud Code is
[05:53] (353.20s)
that it uses the web and it does a lot
[05:55] (355.36s)
of research, but you kind of have to
[05:57] (357.76s)
push it in the right direction. So, here
[05:59] (359.28s)
I have the Cloud Code SDK documentation.
[06:02] (362.72s)
I found it by saying Cloud Code SDK and
[06:06] (366.80s)
then if you go to Google, it's the first
[06:08] (368.32s)
link. So, I'm going to go ahead and grab
[06:09] (369.68s)
this link and I'm going just give it to
[06:11] (371.68s)
Claude on plan mode and be like, "Okay,
[06:14] (374.00s)
look." So, it has the memory that I'm
[06:15] (375.76s)
building a lovable clone, but I want to
[06:17] (377.04s)
use the cloud SDK. Let's just tell it
[06:19] (379.12s)
like, let's focus on using the Claude
[06:24] (384.16s)
code SDK to power my code
[06:29] (389.28s)
gen agent capabilities, codegen features
[06:32] (392.72s)
for my lovable clone.
[06:36] (396.24s)
Lovable clone. For now, let's scope
[06:41] (401.28s)
things down.
[06:43] (403.68s)
So, Lovable is a website that builds
[06:45] (405.28s)
websites. For now, I'm going to build My
[06:47] (407.20s)
background is mainly in backend
[06:49] (409.04s)
engineering, right?
[06:49] (409.92s)
I'm definitely more on the
[06:51] (411.68s)
infrastructure and backend side of
[06:53] (413.68s)
things. So, we're going to stick to that
[06:55] (415.12s)
since this project is pretty orientated
[06:56] (416.72s)
around that. And we're just going to go
[06:57] (417.84s)
ahead and ask it, you know, I want a
[06:59] (419.92s)
function that builds something for me.
[07:02] (422.48s)
And that something is going to be what
[07:03] (423.68s)
should translate. function that you need
[07:04] (424.96s)
to execute. For those of you who aren't
[07:06] (426.24s)
as technical, you want to create a place
[07:08] (428.56s)
that you can type your app idea and it
[07:11] (431.68s)
will execute it or do it and create the
[07:14] (434.32s)
code for that project.
[07:15] (435.68s)
Exactly.
[07:16] (436.40s)
Exactly. So, we're going to go ahead and
[07:18] (438.24s)
tell that we just want the raw
[07:20] (440.48s)
piece of code that you can execute that
[07:22] (442.40s)
will build something for me. And so, I'm
[07:24] (444.16s)
going to translate that a little bit
[07:25] (445.36s)
more tech lingo. Let's scope things
[07:27] (447.04s)
down. I want a function that lets me
[07:31] (451.04s)
input a prompt
[07:33] (453.12s)
and uses claude code to build
[07:38] (458.72s)
it. Let's just see what it does, you
[07:41] (461.44s)
know. Amazing. And so I have it on plan
[07:43] (463.12s)
mode. I don't need to tell it
[07:44] (464.24s)
specifically like, hey, I don't want you
[07:45] (465.60s)
to edit code. I just want you to come up
[07:47] (467.04s)
with a plan. It's currently asking, can
[07:49] (469.04s)
I read this?
[07:50] (470.64s)
Yes, you can. And the cool thing about
[07:52] (472.56s)
this now I can take this time to explain
[07:54] (474.48s)
to you that cloud code will generate
[07:56] (476.48s)
this directory called cloud. Inside of
[07:59] (479.60s)
it it has settings and it just keeps
[08:01] (481.36s)
track of things that you allow and
[08:02] (482.80s)
disallow. And so we have to configure
[08:04] (484.80s)
this when we build software that uses
[08:06] (486.88s)
cloud code to make sure that the SDK
[08:09] (489.12s)
cloud code must also have the correct
[08:11] (491.68s)
permissions so that it can write and
[08:13] (493.68s)
read and do things that you know we kind
[08:15] (495.44s)
of wanted to do.
[08:16] (496.32s)
Let's pause there for a sec. So the same
[08:18] (498.16s)
way that cloud code asks you permission,
[08:20] (500.48s)
right? We are building an app that uses
[08:22] (502.56s)
cloud code. So we need to basically
[08:24] (504.72s)
enable the app that we create to do the
[08:26] (506.80s)
same thing to have the same permissions
[08:28] (508.08s)
that we're granting as we build. Okay.
[08:30] (510.96s)
Exactly. Exactly.
[08:32] (512.32s)
And so it's giving me a lot of things.
[08:34] (514.32s)
Once again, it's giving me like build
[08:36] (516.48s)
simple UI build with next project
[08:38] (518.48s)
implement service class. Like all of
[08:40] (520.88s)
this, you know, we're trying to scope
[08:42] (522.40s)
down. This is probably a good
[08:44] (524.72s)
engineering practice. We should be
[08:46] (526.24s)
having service classes. We should have
[08:48] (528.40s)
simple UI. Pretty simple. But yeah, like
[08:50] (530.48s)
we're going to just say no.
[08:52] (532.56s)
Yeah. Yeah. I like it. I like it.
[08:53] (533.84s)
I just want a simple TypeScript function
[09:01] (541.28s)
takes in a prompt and tries to build it
[09:07] (547.84s)
with Claude code. Don't worry about the
[09:12] (552.80s)
website yet. We want to prove to
[09:16] (556.40s)
ourselves that we can accomplish
[09:21] (561.04s)
the main functionality first. And so,
[09:26] (566.48s)
show me
[09:28] (568.72s)
pseudo code make sure that the clawed
[09:34] (574.16s)
code SDK is configured
[09:36] (576.96s)
to have the right permissions to read
[09:40] (580.64s)
and write automatically. So, yeah. And
[09:43] (583.76s)
what's cool is we're using the SDK of
[09:45] (585.68s)
the tool we're using. So it probably has
[09:47] (587.36s)
good knowledge of the SDK.
[09:48] (588.80s)
You'd think so, but I don't think it
[09:50] (590.16s)
actually does. See, once again, it's
[09:51] (591.60s)
going ahead to like go read about
[09:53] (593.60s)
itself, which is really interesting
[09:55] (595.12s)
because I think the way that this works
[09:58] (598.16s)
is that cloud releases. I think cloud
[10:00] (600.80s)
code came out before four, but four
[10:02] (602.88s)
might have some documentation on cloud
[10:04] (604.48s)
code, but obviously they're probably
[10:06] (606.80s)
they might have even trained cloud 4 on
[10:09] (609.20s)
the implementation of cloud code, but
[10:11] (611.20s)
they definitely don't they're keeping
[10:12] (612.80s)
that closed source.
[10:13] (613.76s)
So its knowledge isn't that great.
[10:15] (615.36s)
It's also like a needle in the haststack
[10:17] (617.04s)
one part of its training data and it's
[10:18] (618.48s)
not going to like know exactly how it's
[10:20] (620.48s)
implemented and be able to remember that
[10:22] (622.24s)
from its training set and just know
[10:23] (623.92s)
about instantly. And also this way it
[10:25] (625.92s)
kind of has a better control of like
[10:27] (627.68s)
what is released to the public and so
[10:29] (629.44s)
whatever it finds online it can know
[10:31] (631.04s)
that like okay I can like definitely use
[10:32] (632.80s)
this. So that's probably all baked into
[10:34] (634.72s)
like the model that they trained itself.
[10:36] (636.32s)
But let's see it kind of has us given me
[10:39] (639.20s)
some pseudo code about you know looks
[10:41] (641.60s)
this looks like okay it's giving itself
[10:43] (643.52s)
tools to use max turns 10. I'll get more
[10:46] (646.88s)
into that later but it kind of looks
[10:48] (648.24s)
like you know it's looping through some
[10:50] (650.24s)
messages and it's looks like a function
[10:52] (652.64s)
to extract code from messages. That's
[10:54] (654.80s)
interesting. It seems like this could
[10:57] (657.20s)
work. So, I'm just going to go ahead get
[10:58] (658.88s)
off of plan mode and get on auto accept
[11:01] (661.20s)
edits mode and say, "Okay, implement
[11:04] (664.16s)
this feature and I want you to test it.
[11:07] (667.68s)
Try and make a simple ticktactoe
[11:12] (672.16s)
game using the function that calls
[11:16] (676.16s)
Claude code SDK.
[11:18] (678.24s)
Let's go, baby.
[11:20] (680.16s)
Make this in HTML for now." And so HTML
[11:26] (686.00s)
is kind of like super bare bones. I
[11:28] (688.00s)
don't need any setup around it. I can
[11:29] (689.84s)
just open it in a browser. And so that's
[11:31] (691.44s)
why we're asking it to build an HTML
[11:33] (693.92s)
first. Later, we can change that to a
[11:35] (695.84s)
next or like a React Native website. So,
[11:39] (699.20s)
okay. Well, sure. Never mind. It wants
[11:41] (701.28s)
to build a website. Why not? It will go
[11:43] (703.20s)
ahead. I'll just let this thing run for
[11:44] (704.80s)
a sec. And so, this thing will always
[11:46] (706.80s)
ask you. There's a way to make this not
[11:49] (709.84s)
ask you, actually,
[11:50] (710.72s)
like similar to yolo mode on cursor.
[11:52] (712.80s)
Yeah. And I can talk about that a little
[11:55] (715.12s)
bit more in a second because if we want
[11:56] (716.96s)
to take this to the next level, we're
[11:58] (718.48s)
actually going to have to make it such
[12:00] (720.16s)
that currently it's going to just write
[12:01] (721.84s)
code. Claude Code, which I'm using right
[12:04] (724.32s)
now, is going to just write code in my
[12:05] (725.84s)
workspace. When we want Claude Code SDK,
[12:09] (729.04s)
which is our lovable coding agent to
[12:11] (731.36s)
write code, we're going to want that to
[12:13] (733.12s)
happen in an isolated environment where
[12:15] (735.60s)
we can let it do whatever it wants.
[12:18] (738.40s)
We're just going to like put it in a
[12:20] (740.16s)
bubble and whatever happens in that
[12:21] (741.44s)
bubble is fine. It can blow up. It can
[12:23] (743.28s)
break. It can like do anything.
[12:24] (744.88s)
It won't affect the main
[12:25] (745.92s)
and it won't affect like my Yeah. The
[12:28] (748.24s)
damage will be contained is that that is
[12:30] (750.16s)
the point. Yeah. And so
[12:32] (752.00s)
if we have time, we can get to that. But
[12:33] (753.76s)
for now, we're going to scale things
[12:35] (755.20s)
down. We're going to let Cloud Code
[12:36] (756.96s)
write something that writes code on my
[12:40] (760.40s)
local machine, which probably isn't like
[12:42] (762.16s)
too good either. Honestly, I should just
[12:43] (763.60s)
spin up a Docker instance. But okay,
[12:45] (765.68s)
simplifying down. Let's see. We have a
[12:49] (769.92s)
main function that wraps Cloud Code SDK
[12:52] (772.88s)
and a test script that uses the generate
[12:55] (775.12s)
how to test it. First, use your
[12:56] (776.64s)
anthropic key in myv file and then run
[13:00] (780.16s)
it. I'm going to go ahead and put a key
[13:02] (782.32s)
here and we're going to make sure you
[13:03] (783.92s)
don't steal that key because this key is
[13:05] (785.76s)
very important. Okay, so I just put the
[13:07] (787.92s)
key in myv file. I've closed it and I
[13:10] (790.32s)
will never open it again because I don't
[13:11] (791.92s)
want you to have my secrets. But it's
[13:14] (794.24s)
telling me I can just, you know, run
[13:16] (796.88s)
this after I put my key in. Let's see if
[13:20] (800.32s)
it works.
[13:21] (801.60s)
So you can just run it in a new
[13:22] (802.80s)
terminal.
[13:23] (803.36s)
Yeah. So this terminal is housing closet
[13:25] (805.20s)
code. So it's busy. This one is a new
[13:27] (807.44s)
terminal. I'm in the same directory.
[13:29] (809.36s)
Just going to try this. Okay. Let's see.
[13:32] (812.56s)
It's planning right now. So we can kind
[13:34] (814.32s)
of see that this is a system message
[13:36] (816.08s)
from Cloud Code. We told it to generate
[13:38] (818.16s)
me a tic-tac-toe game. Cloud Code is
[13:41] (821.28s)
able to use these tools. It's thinking,
[13:43] (823.92s)
I guess. Okay, it's using Opus. Wow,
[13:46] (826.48s)
that's really cool.
[13:47] (827.52s)
Opus 4.
[13:48] (828.48s)
Claude is going to run up my bill with
[13:50] (830.08s)
Claude. So, that's cool. We're gonna
[13:52] (832.32s)
see. So, now what we had is if you
[13:54] (834.96s)
notice, I actually had to run a script.
[13:56] (836.64s)
This is the function that I was talking
[13:57] (837.76s)
about the super bare bones like I just
[14:00] (840.16s)
want a piece of code that uses cloud
[14:01] (841.76s)
code to write code. So, I executed that
[14:03] (843.92s)
piece of code and now cloud code is
[14:05] (845.44s)
writing code. So all these green and
[14:07] (847.04s)
blue and yellow and complicated system
[14:09] (849.12s)
messages, assistant messages are
[14:11] (851.12s)
actually is Claude trying to write code
[14:13] (853.12s)
right now because we ran the code,
[14:15] (855.28s)
So let's kind of see if it ever creates
[14:17] (857.52s)
me anything useful. All I really needed
[14:19] (859.84s)
it to do is write me an HTML file. I can
[14:22] (862.40s)
tell that it's still thinking. Honestly,
[14:24] (864.40s)
that's a little concerning because it
[14:26] (866.32s)
shouldn't think too hard. Code generated
[14:28] (868.88s)
successfully. I need permission to write
[14:31] (871.28s)
this file. So we can see that it doesn't
[14:34] (874.00s)
have permission to write files. And so
[14:35] (875.52s)
I'm gonna go ahead and flame club code
[14:38] (878.00s)
because I explicitly told it to give it
[14:39] (879.76s)
permissions. As you can see,
[14:43] (883.28s)
the function
[14:45] (885.28s)
you wrote does not
[14:48] (888.16s)
allow Claude code to write. Please make
[14:52] (892.48s)
sure all permissions
[14:56] (896.00s)
are granted to the claude
[15:00] (900.32s)
code SDK such that it writes files.
[15:04] (904.96s)
Okay, here are the docs. Again,
[15:10] (910.08s)
just make it work. I'm going to tell it
[15:13] (913.44s)
to fix itself because we've identified
[15:15] (915.76s)
the issue. The issue is
[15:17] (917.92s)
that it basically gave it not enough
[15:20] (920.40s)
permissions to do what it's doing.
[15:21] (921.68s)
That's probably why it thought for
[15:22] (922.72s)
longer than you were comfortable with.
[15:24] (924.16s)
Yeah. Let's see if the test that cloud
[15:26] (926.08s)
code wrote to test this on code is
[15:28] (928.88s)
working. I think in this case it's
[15:31] (931.20s)
actually better than cursor because it's
[15:34] (934.72s)
really annoying to use the terminal that
[15:36] (936.96s)
cursors agent uses, right? But it's
[15:39] (939.68s)
pretty easy to see what the terminal is
[15:42] (942.48s)
doing here because I can click control R
[15:44] (944.96s)
and I can see everything that's going
[15:46] (946.88s)
I definitely get confused using cursors
[15:48] (948.88s)
terminal thing.
[15:50] (950.16s)
Yeah. And what's amazing is we actually
[15:53] (953.12s)
already have I see here tic tactoe.html.
[15:57] (957.68s)
So it built it and put it in the
[15:58] (958.80s)
codebase.
[15:59] (959.44s)
Yeah. And so we can go ahead and open
[16:01] (961.68s)
tic-tac-toe and it open tic tac-toe.
[16:04] (964.56s)
There it is. So our lovable clone which
[16:06] (966.64s)
we haven't built a front end for yet.
[16:08] (968.32s)
Yeah. Yeah. Yeah.
[16:08] (968.96s)
Built this tic-tac-toe game. You want to
[16:11] (971.20s)
let me play you?
[16:11] (971.84s)
Yeah. Yeah. You want to play?
[16:12] (972.64s)
Yeah, let's play.
[16:13] (973.76s)
Make sure this thing works.
[16:16] (976.00s)
Okay. Wow.
[16:19] (979.52s)
I let you win. [ __ ] What are you doing?
[16:21] (981.92s)
What do you mean?
[16:22] (982.88s)
You could have gone there and won.
[16:24] (984.40s)
Oh my god.
[16:26] (986.48s)
I told you to let me win and I let you
[16:28] (988.32s)
win, bro.
[16:28] (988.96s)
And then nobody won.
[16:29] (989.76s)
Let's see what happens. Is there an
[16:30] (990.80s)
animation?
[16:32] (992.48s)
It's a draw.
[16:32] (992.88s)
It's a draw. Okay. Okay. Pretty basic,
[16:34] (994.72s)
but yeah, it is. We now have a function
[16:37] (997.20s)
that writes code specifically HTML code.
[16:40] (1000.40s)
And so let's talk about what we must do
[16:43] (1003.12s)
now and kind of reason through it
[16:44] (1004.72s)
actually with cloud. So this is actually
[16:46] (1006.72s)
one of the best parts. We have a proof
[16:48] (1008.48s)
of concept working as in we are now able
[16:50] (1010.72s)
to use AI to write code for us.
[16:55] (1015.12s)
There's a few things once as you
[16:56] (1016.64s)
mentioned that differentiate this from
[16:58] (1018.00s)
lovable. First of all, we don't have a
[16:59] (1019.68s)
landing page, a real website that houses
[17:02] (1022.00s)
right? And second of all, Lovable can
[17:04] (1024.16s)
make cooler things than a single HTML
[17:06] (1026.72s)
script file.
[17:07] (1027.28s)
So, what do you want to start with?
[17:08] (1028.48s)
And so, there's a few ways we can
[17:10] (1030.56s)
upgrade this to become more like
[17:11] (1031.92s)
Lovable. We can build a website around
[17:13] (1033.68s)
it. We can make this such that the user
[17:15] (1035.92s)
can type in whatever prompt they want
[17:17] (1037.36s)
and it'll try to build it instead of
[17:19] (1039.12s)
hard coding a tic-tac-toe simple game in
[17:22] (1042.64s)
a single HTML file prompt. Right?
[17:24] (1044.88s)
We can do that. We can build a website
[17:26] (1046.32s)
around it. Or we can take this, we can
[17:30] (1050.00s)
start containerizing things and making
[17:32] (1052.96s)
the back end more power.
[17:34] (1054.16s)
So if you don't mind, since I love the
[17:36] (1056.64s)
front end, I think Vibe coders love
[17:38] (1058.24s)
making sure the front end actually looks
[17:39] (1059.68s)
like a wrapper.
[17:40] (1060.48s)
We can take a screenshot.
[17:41] (1061.60s)
Wait, can you throw it on dark mode at
[17:42] (1062.72s)
least? I think the dark mode version of
[17:44] (1064.24s)
their site is better.
[17:45] (1065.92s)
Oh, there we go. Okay, great. You want
[17:48] (1068.24s)
the dark mode clone? We got the dark
[17:50] (1070.16s)
mode clone. What I was saying was you
[17:51] (1071.84s)
can grab the screenshot. It can actually
[17:55] (1075.04s)
digest images as well. If we want to
[17:56] (1076.88s)
clone the dark mode of lovable, we can
[17:58] (1078.96s)
go ahead and screenshot this and we can
[18:01] (1081.92s)
go ahead and copy this screenshot
[18:06] (1086.08s)
and go back to cloud code and we can
[18:08] (1088.40s)
just paste it in. And so we can say
[18:10] (1090.48s)
something like let's continue our
[18:13] (1093.76s)
project by building out the UI. We have
[18:18] (1098.48s)
tested it and our function works for
[18:22] (1102.48s)
now. Let's focus on building a website
[18:26] (1106.96s)
that mirrors the current lovable
[18:30] (1110.56s)
website. I want the soft gradients and a
[18:36] (1116.56s)
text input. I notice that, you know,
[18:38] (1118.32s)
there's a lot of like buttons and tabs
[18:40] (1120.72s)
here. I don't really care about this. I
[18:42] (1122.40s)
just want this to work like the nav bar
[18:46] (1126.00s)
on top, the hero of the website. So,
[18:50] (1130.32s)
let's kind of see what it does. There's
[18:51] (1131.52s)
a few ways it can take this approach. It
[18:53] (1133.28s)
can build a next project. It can build a
[18:54] (1134.64s)
React project. I've seen it. Yeah, it
[18:56] (1136.24s)
likes to default to next. I'll just let
[18:58] (1138.08s)
it do its thing. I'm not a really good
[18:59] (1139.76s)
front-end engineer, so I have some idea
[19:01] (1141.92s)
of what's going on. For the most part,
[19:03] (1143.44s)
I'm kind of like fumbling through the
[19:05] (1145.04s)
dark, too. I noticed it ran the project
[19:07] (1147.84s)
starter script, which will give me a lot
[19:12] (1152.00s)
oh, lovable UI title. Lovable clone.
[19:14] (1154.32s)
Okay, so it's like laying out the
[19:16] (1156.24s)
websites. Websites have metadata.
[19:17] (1157.76s)
Honestly, this is taking it a little too
[19:19] (1159.36s)
far. like I don't really need this
[19:20] (1160.88s)
stuff. Okay, but it seems like it's
[19:23] (1163.36s)
running things fast enough. It's telling
[19:25] (1165.20s)
me to change directories and run the dev
[19:27] (1167.36s)
server. It's figuring it out. I need to
[19:29] (1169.84s)
go into this directory and run the dev
[19:32] (1172.64s)
server to see it. So, I can go ahead and
[19:35] (1175.12s)
run this. It tells me it's running.
[19:36] (1176.80s)
Click on local host.
[19:37] (1177.76s)
And now local host will be here.
[19:40] (1180.88s)
Oh, okay. All right. It's kind of there.
[19:43] (1183.44s)
Like I don't have the gradient. Um
[19:45] (1185.52s)
that's why I wanted to snag the
[19:46] (1186.72s)
gradient. I don't have the logo.
[19:49] (1189.60s)
I mean I mean I didn't expect it to
[19:50] (1190.96s)
build the logo, but you want to test it.
[19:52] (1192.72s)
We can try giving it a better prompt.
[19:55] (1195.36s)
I don't see the gradient. I would like a
[20:00] (1200.32s)
gradient similar to lovables
[20:03] (1203.84s)
as in an orange circle
[20:08] (1208.40s)
into pink circle
[20:09] (1209.36s)
into pink
[20:12] (1212.16s)
into black.
[20:13] (1213.12s)
Black. Give that a try. And then I think
[20:16] (1216.16s)
you should do one other thing which is
[20:18] (1218.48s)
um make the input area by default three
[20:24] (1224.48s)
by default three lines high. You like
[20:26] (1226.08s)
lovables
[20:26] (1226.72s)
also the input area is a little small.
[20:32] (1232.00s)
Lovables is around uh
[20:35] (1235.20s)
three lines high by default.
[20:36] (1236.56s)
Three lines height
[20:39] (1239.60s)
by default. Ours is one. And then also,
[20:43] (1243.04s)
make the generate button an up arrow
[20:45] (1245.04s)
instead of the generate thing.
[20:47] (1247.28s)
Oh yeah, sure. Also make the generate
[20:51] (1251.36s)
button and up arrow instead of the color
[20:56] (1256.80s)
full button has right now.
[21:01] (1261.20s)
I think we just give it the photo again.
[21:03] (1263.92s)
Okay. Okay.
[21:07] (1267.12s)
I dig it.
[21:08] (1268.00s)
I dig it. I dig it. So now let's talk
[21:10] (1270.96s)
about some more problems that we're
[21:13] (1273.20s)
going to face kind of immediately down
[21:14] (1274.72s)
the line. Uh number one is we have a few
[21:18] (1278.00s)
options. We can either allow it to
[21:20] (1280.32s)
continue writing directly to our local
[21:22] (1282.24s)
machine and by that I mean it's just
[21:25] (1285.28s)
going to write like a folder in here or
[21:28] (1288.00s)
something with like let's project one,
[21:31] (1291.28s)
right? or I guess currently it just kind
[21:33] (1293.44s)
of like writes HTML files in my root
[21:36] (1296.00s)
directory which isn't exactly how we
[21:38] (1298.00s)
want things to go and isn't very easily
[21:40] (1300.32s)
like productizable or scalable at all
[21:42] (1302.32s)
either and that plays a issue when you
[21:44] (1304.40s)
try to route into the results. We can
[21:46] (1306.72s)
try to get that but there's going to be
[21:48] (1308.16s)
some clunkiness in like getting the
[21:51] (1311.44s)
website to open the website it just
[21:54] (1314.48s)
built. That's going to be one issue that
[21:56] (1316.00s)
we can solve pretty easily actually. So
[21:58] (1318.24s)
we'll we'll probably tackle that next.
[22:00] (1320.16s)
Can you hook it up such that the prompt
[22:04] (1324.48s)
inside the text input is sent to the
[22:08] (1328.72s)
function we wrote that uses claude code
[22:13] (1333.04s)
SDK to generate code.
[22:15] (1335.28s)
So yeah, let's go ahead and tell it to
[22:17] (1337.36s)
hook everything up. Make sure
[22:18] (1338.56s)
amazing because before it tested itself,
[22:20] (1340.96s)
it made tic-tac-toe and it worked. And
[22:22] (1342.64s)
we also created this front end. The
[22:24] (1344.16s)
problem is that they're not connected
[22:25] (1345.52s)
and we need it to be connected. So the
[22:27] (1347.20s)
function that we made is a standalone
[22:28] (1348.80s)
function that lives right here. It's
[22:30] (1350.48s)
going to go ahead and move that into our
[22:31] (1351.92s)
website which I see it doing right now.
[22:34] (1354.32s)
And then that way when the website sends
[22:36] (1356.40s)
that it will be able to make an API call
[22:39] (1359.84s)
to that. Yeah. So update the front end
[22:42] (1362.16s)
to call API to display messages add
[22:44] (1364.64s)
message display component. So yeah it's
[22:46] (1366.16s)
got a few things to build out. This is
[22:47] (1367.68s)
actually it's going to earlier into this
[22:49] (1369.68s)
session we saw all of these. It's going
[22:52] (1372.56s)
to try to parse these and render these
[22:54] (1374.08s)
as well as something ideally more
[22:56] (1376.96s)
readable than this. This is pretty ugly.
[22:59] (1379.12s)
So I kind of gave it that task to kind
[23:00] (1380.72s)
of hook up the first thing that we built
[23:02] (1382.24s)
which was the function that you know
[23:03] (1383.84s)
we've tested and proved can build
[23:05] (1385.36s)
tic-tac-toe and hook that up to the
[23:07] (1387.92s)
button inside of here.
[23:09] (1389.60s)
Right.
[23:10] (1390.56s)
Amazing.
[23:11] (1391.28s)
And then so what I understand is this
[23:13] (1393.44s)
becomes like chat on the left and then
[23:15] (1395.04s)
it becomes the website preview on the
[23:16] (1396.48s)
right.
[23:16] (1396.72s)
Correct.
[23:17] (1397.12s)
Okay. Great. Yeah. We can tell it to do
[23:19] (1399.52s)
that too after this. That is so cool.
[23:22] (1402.08s)
So once again, it was trying to go into
[23:24] (1404.56s)
the website and run the dev server. And
[23:26] (1406.96s)
once again, that has an issue because
[23:28] (1408.64s)
its terminal is shorter lived than
[23:30] (1410.40s)
itself. So every time it tries I try to
[23:32] (1412.64s)
open it after it runs it, it's not
[23:34] (1414.40s)
actually open.
[23:35] (1415.28s)
Could you put like a rule in for your
[23:37] (1417.04s)
like whatever the longer memory is
[23:38] (1418.96s)
called? So that says like always just
[23:41] (1421.04s)
tell me when to run the dev server
[23:42] (1422.48s)
instead of doing it.
[23:43] (1423.36s)
Yeah. Yeah, that would probably This is
[23:44] (1424.80s)
a great example of something that would
[23:46] (1426.32s)
actually belong in like the long-term
[23:48] (1428.32s)
memory. Okay, I could definitely save
[23:50] (1430.08s)
that to user memory. You're right. I'll
[23:51] (1431.52s)
just save that to longterm memory. Good
[23:53] (1433.04s)
to know. Great. Thanks. I'm going to
[23:54] (1434.64s)
restart this dev server. I don't think
[23:56] (1436.40s)
it needs to, but we're just gonna see if
[23:59] (1439.36s)
this is still
[24:00] (1440.32s)
It's done.
[24:01] (1441.52s)
So, it it was trying to start it
[24:03] (1443.20s)
earlier. So, make me connect 4. Let's
[24:06] (1446.56s)
see what it does. It's currently
[24:08] (1448.56s)
loading. I'm expecting like some user
[24:10] (1450.56s)
messages or, you know, at least some
[24:12] (1452.80s)
logs on the back end. Generating code
[24:15] (1455.20s)
for prompt make me connect 4.
[24:16] (1456.72s)
Amazing. We are seeing some indication
[24:19] (1459.84s)
of life.
[24:21] (1461.12s)
Okay. Um,
[24:21] (1461.84s)
and it's not immediately failing. So,
[24:23] (1463.44s)
that's good.
[24:24] (1464.00s)
It's not immediately failing. I have a
[24:25] (1465.84s)
theory that it will just make me another
[24:29] (1469.12s)
HTML file. We could probably embed HTML
[24:32] (1472.48s)
as an iframe, but what we truly want is
[24:35] (1475.36s)
like probably for it to go and write its
[24:38] (1478.24s)
own next website. Oh, no way. Let's go.
[24:42] (1482.48s)
Okay. So, it actually did run and it has
[24:46] (1486.00s)
its whole like thought process here.
[24:49] (1489.84s)
let's kind of digest what it's given us.
[24:51] (1491.84s)
So, it's given us, you know, it's
[24:53] (1493.28s)
calling tools like reading files. It's
[24:55] (1495.52s)
reading a bunch of stuff that it
[24:57] (1497.44s)
shouldn't be reading, right? So, for
[24:58] (1498.64s)
example, it's reading all of the code
[25:00] (1500.96s)
for the website when instead I asked it
[25:03] (1503.84s)
to make me connect 4. And then it I've
[25:07] (1507.04s)
created a connect four for you, but
[25:09] (1509.36s)
where? So, let's see. Let's look through
[25:12] (1512.00s)
the code again. Do you have Connect 4
[25:14] (1514.32s)
anywhere? Uh let's see. Connect 4. We do
[25:18] (1518.48s)
have a page with connect 4. Now it's
[25:21] (1521.92s)
inside of my lovable UI app. And so this
[25:24] (1524.96s)
is kind of what I was mentioning before.
[25:26] (1526.48s)
It's about where the code that is being
[25:28] (1528.24s)
generated lives. This is about like this
[25:30] (1530.56s)
becomes a question about scalability
[25:32] (1532.56s)
environments and where you want to run
[25:36] (1536.56s)
code, where you want the code to be
[25:38] (1538.08s)
created to be housed and how can you
[25:40] (1540.48s)
orchestrate everything such that it
[25:42] (1542.16s)
comes back and shows up on your website.
[25:44] (1544.08s)
This is actually like great and all
[25:46] (1546.24s)
because I'm pretty sure that we can
[25:48] (1548.24s)
access this connect for website that we
[25:50] (1550.00s)
just generated by
[25:51] (1551.76s)
could you just go to localhost
[25:54] (1554.00s)
slash 3000 or connect 4 maybe or
[25:56] (1556.40s)
something?
[25:56] (1556.88s)
I think so. Literally. Yes, probably.
[25:59] (1559.28s)
Let's try that. Slash connect four. And
[26:02] (1562.16s)
we have four. That's absolutely correct.
[26:05] (1565.04s)
It did just
[26:05] (1565.84s)
Can you try and put a little guy in
[26:07] (1567.04s)
there or uh place a piece?
[26:08] (1568.40s)
Oh, yeah. Sure.
[26:09] (1569.68s)
Nice. Place another one. Nice. Can you
[26:11] (1571.52s)
make one of them win? I just want to see
[26:13] (1573.04s)
what happens. That's cool. Let's go.
[26:15] (1575.36s)
Ah, yellow wins.
[26:16] (1576.16s)
Player two wins. Let's go. All right.
[26:18] (1578.24s)
So, it works. It just doesn't And it's
[26:20] (1580.72s)
just basically it creates a new file in
[26:22] (1582.40s)
your actual codebase, which is not what
[26:24] (1584.64s)
you think we should do. that's really
[26:26] (1586.08s)
bad on multiple fronts. You know, I can
[26:28] (1588.80s)
make it such that some bad code, I can
[26:31] (1591.92s)
make it say not nice things and it would
[26:33] (1593.76s)
just be on my website as a URL. I think
[26:36] (1596.32s)
there's a lot of other improvements we
[26:37] (1597.76s)
can make on the middle ground as well,
[26:39] (1599.20s)
such as telling it, hey, I want real
[26:41] (1601.44s)
time messages to be like shown cuz you
[26:44] (1604.72s)
what we saw was after its whole thought
[26:47] (1607.04s)
process, it showed all of its thought
[26:48] (1608.96s)
process. We want this in real time. We
[26:50] (1610.56s)
could say something like that. All the
[26:52] (1612.24s)
messages shown to us were computer
[26:54] (1614.00s)
speak. We can make it not computer speak
[26:56] (1616.24s)
or like
[26:57] (1617.68s)
more friendly. We can render more
[26:58] (1618.88s)
friendly text or only strip out the
[27:00] (1620.96s)
important parts. We can also make it
[27:03] (1623.68s)
open the page that it made after.
[27:06] (1626.08s)
We can do all of that or we can start
[27:08] (1628.00s)
putting things into Docker images and
[27:10] (1630.88s)
hosting isolated environments. Where do
[27:12] (1632.40s)
you want to think?
[27:12] (1632.88s)
I don't have an idea of how long either
[27:15] (1635.04s)
of those would take. I think I would
[27:16] (1636.96s)
defer to you. We should make this as
[27:18] (1638.88s)
close to lovable as we can in the next
[27:21] (1641.20s)
hour and under that frame you decide.
[27:23] (1643.68s)
Cool. I'm going to go ahead and I really
[27:26] (1646.48s)
hated the process of not knowing what's
[27:28] (1648.08s)
going on. So, I'm going to do a little
[27:29] (1649.28s)
bit of house cleaning with this code
[27:31] (1651.68s)
And so, a lot of what that means is
[27:33] (1653.12s)
okay, great job. Cloud code is a little
[27:35] (1655.60s)
child. You got to tell it good boy all
[27:37] (1657.12s)
the time. Great job. It actually does, I
[27:39] (1659.60s)
think, respond better because you
[27:41] (1661.36s)
positively enforce that what it has done
[27:43] (1663.44s)
is in the right direction. So, as long
[27:45] (1665.12s)
as whatever it's doing is in the right
[27:46] (1666.72s)
direction, you want to generally follow
[27:47] (1667.92s)
it up with something to indicate to the
[27:50] (1670.08s)
LLM that whatever it did was in the
[27:51] (1671.84s)
right direction of what you're trying to
[27:52] (1672.96s)
build. And so, that's why I kind of
[27:54] (1674.32s)
begin this with great job and I'll say
[27:56] (1676.32s)
exactly what it did, right? In this
[27:58] (1678.96s)
case, you made it such that the website
[28:03] (1683.28s)
builds a page
[28:07] (1687.20s)
builds a page within itself
[28:10] (1690.96s)
based on the prompt. And we notice that
[28:13] (1693.60s)
because uh when we go to slashconnect 4,
[28:17] (1697.76s)
it will it's in it's within itself.
[28:19] (1699.84s)
Yeah. So we're gonna reiterate to itself
[28:21] (1701.68s)
what it did. This is in the right
[28:23] (1703.04s)
direction. There are a few problems
[28:25] (1705.84s)
though. There are no logs in the back
[28:29] (1709.04s)
end except until it successfully
[28:32] (1712.72s)
finishes and when it begins. I want more
[28:37] (1717.12s)
logs throughout
[28:39] (1719.68s)
the code gen code generation process.
[28:45] (1725.28s)
Similarly, the messages don't show up
[28:49] (1729.60s)
until the whole conversation is
[28:53] (1733.44s)
complete. I would like these I would
[28:57] (1737.68s)
like real-time logs.
[29:00] (1740.32s)
Ideally,
[29:03] (1743.12s)
you should just display
[29:06] (1746.88s)
the user agent message, assistant
[29:10] (1750.08s)
message, assistant message, and maybe
[29:13] (1753.60s)
tool call names. Make sure not
[29:15] (1755.92s)
everything comes at the end. Also, I
[29:17] (1757.84s)
would like you to try and open the
[29:20] (1760.80s)
website that was created from the
[29:23] (1763.92s)
prompt. Not I guess not the website, but
[29:25] (1765.92s)
the the page that was created from the
[29:29] (1769.04s)
prompt.
[29:31] (1771.28s)
I.e. last time we asked it to make
[29:35] (1775.52s)
connect for
[29:38] (1778.96s)
I created a git repo. I want you to
[29:42] (1782.24s)
create this as a PR. Now we can run
[29:45] (1785.52s)
We'll see if it cooks.
[29:46] (1786.56s)
And then after that we get into some
[29:48] (1788.08s)
more really nitty-gritty technical
[29:50] (1790.24s)
things like we're going to find a way to
[29:52] (1792.88s)
create an isolated environment. We can
[29:54] (1794.96s)
do that locally first on our machine
[29:56] (1796.80s)
with Docker to create this little bubble
[29:59] (1799.12s)
where all the damage inside can be
[30:00] (1800.80s)
contained and then we can run a bunch of
[30:03] (1803.04s)
things in that bubble and then we can
[30:05] (1805.36s)
put that bubble on someone else's
[30:06] (1806.88s)
computer using putting it basic that's
[30:09] (1809.52s)
like putting it on the server putting on
[30:11] (1811.28s)
and then we can run this on the cloud
[30:13] (1813.44s)
and then the good thing about that is
[30:15] (1815.28s)
now if you imagine this bubble as a
[30:17] (1817.36s)
separate new nex.js JS project. That way
[30:20] (1820.88s)
it's a full standalone website instead
[30:23] (1823.28s)
of a page inside of my website.
[30:25] (1825.76s)
Makes sense. And you can add many files
[30:27] (1827.60s)
to it in theory.
[30:28] (1828.56s)
I mean, I think you could technically
[30:30] (1830.16s)
nest a bunch of
[30:31] (1831.92s)
that would that would be insane.
[30:33] (1833.68s)
It would be bloating my website. I don't
[30:35] (1835.52s)
actually want the lovable website to be
[30:37] (1837.12s)
changed every time someone comes on and
[30:38] (1838.64s)
writes a prompt. That's a terrible
[30:40] (1840.00s)
design pattern. We'll try to vive code
[30:41] (1841.60s)
it all, but
[30:42] (1842.08s)
we're going to v code it.
[30:42] (1842.96s)
It's currently doing some git stuff,
[30:44] (1844.88s)
making me a git ignore. But definitely
[30:47] (1847.12s)
this is more of the since we're live on
[30:49] (1849.28s)
podcast and I have previous experience I
[30:51] (1851.12s)
don't need to do research but this would
[30:52] (1852.64s)
be a deep question that I would research
[30:54] (1854.96s)
like how do I make it stop editing my
[30:57] (1857.68s)
codebase directly and go create another
[30:59] (1859.84s)
codebase where does that codebase live
[31:01] (1861.60s)
and how do I port it into yeah so off
[31:03] (1863.92s)
the top of my head I know there are many
[31:07] (1867.20s)
software companies that provide isolated
[31:10] (1870.24s)
environments I think they're that's a
[31:12] (1872.08s)
pretty hot space they're like the people
[31:13] (1873.52s)
selling shovels to companies like us who
[31:15] (1875.44s)
want to build AI agents that run codegen
[31:17] (1877.92s)
because it is a problem that we need to
[31:19] (1879.84s)
solve. That's definitely like another
[31:21] (1881.92s)
software
[31:22] (1882.56s)
E2B or
[31:23] (1883.44s)
E2B is a great example. Daytona is
[31:25] (1885.44s)
another one. They're both kind of built
[31:27] (1887.44s)
around giving you this bubble that you
[31:29] (1889.60s)
can do whatever you want in and then
[31:31] (1891.92s)
letting you also peek into that bubble
[31:34] (1894.16s)
and see the code output of the agent.
[31:36] (1896.40s)
And so that's kind of what we're going
[31:37] (1897.52s)
to do next. We're going to go and spawn
[31:38] (1898.88s)
a little bubble using one of these
[31:40] (1900.88s)
isolated environment providers and we're
[31:43] (1903.04s)
going to go and tell cloud code to write
[31:45] (1905.28s)
the stuff in there and then show me
[31:46] (1906.80s)
what's in there instead of directly
[31:48] (1908.56s)
editing my website. Run the npm rundev.
[31:51] (1911.12s)
Okay, let's see if it has real time
[31:54] (1914.48s)
better messaging now.
[31:56] (1916.64s)
So, back to UI.
[31:58] (1918.80s)
Amazing.
[31:59] (1919.44s)
Make me I want this to like run for as
[32:02] (1922.24s)
minimal time as possible and get into
[32:03] (1923.84s)
like the like bubbling stuff. So I'm
[32:05] (1925.52s)
just going to say make me a screen that
[32:08] (1928.16s)
says hello world. Very basic. Okay. So
[32:11] (1931.92s)
we're seeing like
[32:12] (1932.64s)
my assistants doing some
[32:14] (1934.00s)
a lot of things already. Okay. Yeah. So
[32:15] (1935.92s)
as you can see it's already like so this
[32:19] (1939.12s)
is a lot better display. Let me check if
[32:21] (1941.92s)
the existing project. Okay. So once
[32:25] (1945.28s)
it told me that it's going to check the
[32:27] (1947.04s)
existing structure of your project my
[32:29] (1949.36s)
project to understand. Now it's going to
[32:31] (1951.52s)
go and read through all this junk. I
[32:33] (1953.84s)
mean, by this junk, I mean like this
[32:35] (1955.20s)
website itself, which is the exact
[32:37] (1957.60s)
problem that I don't want it to have,
[32:39] (1959.52s)
which is why I have no doubt that it's
[32:41] (1961.76s)
going to go and make me a screen that
[32:43] (1963.04s)
says hello world. But I'm going to go
[32:45] (1965.12s)
and make it such that instead of on my
[32:47] (1967.04s)
website, it goes and opens a bubble in
[32:50] (1970.24s)
the cloud and writes it there instead.
[32:52] (1972.32s)
And so to do that, I'm going to go and
[32:54] (1974.40s)
yeah, you can see that it's talking to
[32:55] (1975.92s)
itself, but we have an animation. We
[32:57] (1977.52s)
have some sort of indication that
[32:58] (1978.72s)
something's going on. I'm gonna go do a
[33:00] (1980.80s)
little bit of research on E2B's docs.
[33:03] (1983.92s)
E2B.dev.
[33:05] (1985.52s)
I think I do have an account here.
[33:09] (1989.12s)
Okay, we used to use E2B for our Vibe
[33:11] (1991.36s)
Code, but not anymore. I will have to
[33:14] (1994.00s)
build a new template for it with Docker
[33:16] (1996.32s)
and everything. Let's go to docs for E2B
[33:19] (1999.76s)
docs. And then I have a rough idea of
[33:22] (2002.64s)
how this works, but I'm going to like
[33:24] (2004.40s)
try to pretend like I don't. And I'm
[33:26] (2006.48s)
going to just go and tell cloud code to
[33:28] (2008.80s)
research this.
[33:29] (2009.84s)
So once again, the big idea is we need
[33:32] (2012.16s)
to create these bubbles such that
[33:34] (2014.08s)
whatever is created there is
[33:36] (2016.00s)
isolated. It also can peak into it. We
[33:38] (2018.08s)
can see it happen on our on our end.
[33:40] (2020.08s)
It's exploring. Sometimes it's like
[33:42] (2022.64s)
cloud code really likes to explore a
[33:44] (2024.56s)
bunch of stuff and oh look as we can see
[33:46] (2026.64s)
it just made hello world which is this
[33:48] (2028.88s)
cloud code over here actually just made
[33:51] (2031.60s)
Oh. So now if you just do go to
[33:53] (2033.68s)
localhost/hello world probably
[33:55] (2035.84s)
it told us this right now. If you can
[33:58] (2038.16s)
you can start the dev server and
[33:59] (2039.84s)
navigate to localhost 3000/hello world.
[34:03] (2043.44s)
If we do that wow they gave us a
[34:05] (2045.76s)
gradient. The point is once like it's
[34:08] (2048.64s)
pretty good because it actually went
[34:10] (2050.40s)
ahead and told us which website to go
[34:12] (2052.64s)
to. And so that's a super small change
[34:14] (2054.72s)
from it telling us which website to go
[34:16] (2056.40s)
to to just making it a link that's
[34:17] (2057.92s)
clickable. But this is something else.
[34:20] (2060.32s)
Cloud code likes to do a lot of
[34:21] (2061.52s)
dillydally searching. It makes it very
[34:24] (2064.00s)
powerful, but I don't want to wait for
[34:26] (2066.24s)
all this junk to happen. I'm just going
[34:28] (2068.48s)
to tell it what to do differently, and
[34:29] (2069.76s)
I'm going to tell it what I need it to
[34:31] (2071.04s)
do. So, it was trying to gain some
[34:33] (2073.68s)
context on what this project was. I can
[34:35] (2075.92s)
go ahead and tell it or I can just put
[34:37] (2077.44s)
it into my cloud. MD file. It should
[34:40] (2080.64s)
have this. It knows that I'm a lovable
[34:42] (2082.48s)
clone. Okay, I'll just go ahead and
[34:44] (2084.48s)
actually save this to memory so it
[34:45] (2085.76s)
doesn't need a search too much. We have
[34:48] (2088.00s)
so far
[34:50] (2090.40s)
a website that takes in a prompt uses
[34:55] (2095.60s)
claude code SDK to write code
[34:59] (2099.44s)
but currently it stores it in our
[35:00] (2100.80s)
codebase
[35:01] (2101.92s)
but currently
[35:04] (2104.00s)
it directly modifies my website's code
[35:09] (2109.12s)
by adding it as a page
[35:12] (2112.72s)
page. The next task
[35:17] (2117.12s)
we are going to work on going to work on
[35:21] (2121.52s)
is making the code gen happen in an
[35:27] (2127.52s)
isolated environment and opening the dev
[35:33] (2133.84s)
server there. We're going to keep this
[35:35] (2135.60s)
in local. So now we're going to tell it
[35:37] (2137.68s)
E2B or we can use Daytona as well.
[35:40] (2140.00s)
Honestly, that would be probably pretty
[35:41] (2141.68s)
interesting because I've used E2B
[35:43] (2143.28s)
before. Let's just do a fresh like
[35:46] (2146.08s)
use something you've never used.
[35:47] (2147.12s)
Use something I've never used. Just
[35:48] (2148.40s)
purely vibe code this thing.
[35:49] (2149.76s)
All right, let's purely vibe code it.
[35:51] (2151.12s)
Purely vibe.
[35:51] (2151.84s)
So, we're going to be using Daytona to
[35:53] (2153.52s)
create these little bubbles that
[35:55] (2155.12s)
people's code will be created and run
[35:58] (2158.16s)
and that is the code that we will show
[36:00] (2160.00s)
on the site.
[36:00] (2160.80s)
Yeah, exactly. And so, oh crap, I need
[36:03] (2163.76s)
to get an API key. So,
[36:04] (2164.88s)
let's get an API key.
[36:06] (2166.00s)
So, I just put Daytona in my ENV key in
[36:08] (2168.16s)
my environmental firewall. So, I'm going
[36:10] (2170.00s)
to tell it. Let's talk a little bit
[36:11] (2171.36s)
about how I arrived here. To reiterate,
[36:14] (2174.00s)
the main problem was that we have an
[36:16] (2176.32s)
agent that writes code, but it writes
[36:17] (2177.76s)
code directly on our website. Instead,
[36:19] (2179.20s)
we want that code to be somewhere else,
[36:20] (2180.48s)
and we want our website to be able to
[36:22] (2182.00s)
show that code
[36:23] (2183.52s)
some written and housed somewhere else.
[36:26] (2186.00s)
And so, the way that we need this is we
[36:28] (2188.00s)
need someone else to house the code that
[36:30] (2190.24s)
our agent writes.
[36:31] (2191.60s)
And so,
[36:33] (2193.36s)
we're using Daytona.
[36:34] (2194.56s)
Daytona is a provider of these little
[36:36] (2196.24s)
bubbles. and we're going to so I'm going
[36:38] (2198.48s)
to go ahead and tell it I want to
[36:42] (2202.40s)
instead
[36:44] (2204.00s)
make the code gen happen in an isolated
[36:51] (2211.44s)
environment.
[36:53] (2213.20s)
I have made I have given you a Daytona
[37:00] (2220.64s)
inside thev file. I want you to read the
[37:05] (2225.92s)
docs on daytona.
[37:10] (2230.00s)
Verify that it can do what we want. And
[37:14] (2234.72s)
the end goal is to have the clawed
[37:19] (2239.84s)
code SDK
[37:22] (2242.08s)
create a new React Nex.js Nex.js website
[37:28] (2248.08s)
inside of the isolated environment.
[37:30] (2250.72s)
Don't worry about connecting the text
[37:35] (2255.76s)
input for now. I just want to validate
[37:40] (2260.72s)
that we can run the at@ generate cloud
[37:46] (2266.64s)
generate with cloud code function or
[37:49] (2269.04s)
something similar
[37:51] (2271.84s)
in a Daytona
[37:54] (2274.16s)
sandbox. I've been saying isolated
[37:56] (2276.00s)
environment. I'm going to feed it to
[37:57] (2277.04s)
docs now. You should have docs
[37:58] (2278.32s)
somewhere, right? So just like cursor,
[37:59] (2279.84s)
you can paste links to docs and cloud
[38:02] (2282.08s)
code comes equipped with the tool of
[38:03] (2283.68s)
being able to search the web and do
[38:05] (2285.04s)
research.
[38:05] (2285.60s)
Yeah. And it should ideally be able to
[38:07] (2287.68s)
continue searching down sublinks. So I
[38:09] (2289.92s)
gave it a pretty broad link the whole
[38:11] (2291.92s)
documentation link.
[38:12] (2292.80s)
But it'll search and find which part of
[38:14] (2294.72s)
the docs it needs. Navigate to that and
[38:16] (2296.40s)
then search that one.
[38:17] (2297.36s)
Yeah, I'll just turn on plan mode and
[38:18] (2298.72s)
see what it says.
[38:19] (2299.68s)
All right. It's a big prompt, big task.
[38:22] (2302.80s)
At least
[38:23] (2303.28s)
a lot of buzzwords have been going
[38:24] (2304.48s)
around about prompt engineering. I think
[38:26] (2306.24s)
a lot of prompt engineering is being
[38:27] (2307.92s)
clear about the end goal, what to focus
[38:30] (2310.32s)
on now, and all the things you need to
[38:33] (2313.12s)
get to the current goal of what you're
[38:34] (2314.96s)
focusing on now. I think it's good to
[38:36] (2316.88s)
give some indication of the direction of
[38:38] (2318.64s)
the end state. But it's most important
[38:40] (2320.72s)
to frame and iterate to the agent that
[38:42] (2322.96s)
we're working on a smaller chunk, but to
[38:46] (2326.24s)
still have its eyes set on the end goal.
[38:48] (2328.32s)
so because you see a lot of times when
[38:50] (2330.08s)
you tell cursor to do something that's
[38:51] (2331.76s)
apparently obvious in your brain and it
[38:53] (2333.92s)
does it completely wrong it's because it
[38:56] (2336.16s)
doesn't share the same end goal as you
[38:58] (2338.08s)
and so that's why I like to always give
[38:59] (2339.52s)
it a little peak of what the final goal
[39:01] (2341.12s)
is but I like to if you give it like too
[39:03] (2343.68s)
much to work on it'll obviously get lost
[39:06] (2346.40s)
in the sauce and
[39:07] (2347.44s)
there's also a difference between final
[39:08] (2348.80s)
end goal and then the iteration end goal
[39:10] (2350.80s)
or the current task end goal.
[39:12] (2352.72s)
Yes. I want instead I want to instead
[39:14] (2354.80s)
make the cogen happen in an isolated
[39:16] (2356.32s)
environment. This is the end result or I
[39:18] (2358.72s)
guess this is actually to create a
[39:20] (2360.40s)
Nex.js inside of the isolated
[39:22] (2362.24s)
environment. Don't worry about
[39:23] (2363.68s)
connecting the input for now. Just I
[39:25] (2365.44s)
want to validate we can run. So this is
[39:27] (2367.68s)
what I mean by scoping down. The end
[39:30] (2370.00s)
goal is to have the whole Nex.js website
[39:32] (2372.88s)
inside the isolated environment be spun
[39:34] (2374.80s)
up by cloud code. I told it instead just
[39:37] (2377.52s)
work on being able to run cloud code
[39:39] (2379.28s)
inside of the isolated environment
[39:40] (2380.80s)
first. Okay, it gave me a plan. Let's
[39:43] (2383.04s)
see. It's telling me to install the SDK.
[39:46] (2386.16s)
Create an integration. Integrate with
[39:49] (2389.28s)
initialize the client with API key.
[39:51] (2391.60s)
Yeah, we gave it the API key. Implement
[39:53] (2393.76s)
Nex.js project creation in sandbox.
[39:56] (2396.24s)
Create a new sandbox generation
[39:57] (2397.76s)
function. That's true. We're going to
[39:58] (2398.96s)
need that. Update the API routes. Test
[40:00] (2400.64s)
the script. And see, once again, it's
[40:03] (2403.12s)
telling me to do this is the end result,
[40:05] (2405.60s)
right? This is actually really good.
[40:06] (2406.96s)
Test validation. create a simple test
[40:08] (2408.64s)
that creates a Daytona sandbox, runs a
[40:11] (2411.12s)
modified version, and creates a basic
[40:13] (2413.44s)
Nex.js app. Yeah. And return to preview
[40:15] (2415.68s)
your app. This is perfect. So, we're
[40:17] (2417.44s)
going to go ahead and say the plan is
[40:19] (2419.20s)
great. I want you to go ahead
[40:24] (2424.00s)
and focus only on the test validation
[40:27] (2427.84s)
for now. I also did some research and
[40:32] (2432.64s)
found out that you probably want a
[40:36] (2436.72s)
custom Docker image so that Claude code
[40:40] (2440.72s)
can run inside the isolated environment.
[40:44] (2444.40s)
Have you taken this into account? Plan
[40:48] (2448.32s)
out the test script
[40:51] (2451.76s)
in more detail. Show pseudo/real
[40:56] (2456.16s)
code. And so this way it's doing another
[40:58] (2458.40s)
plan session. I told it to be a little
[41:00] (2460.08s)
bit more detailed about what it's
[41:01] (2461.52s)
planning. Show me the code, how
[41:04] (2464.08s)
everything's going to come together and
[41:05] (2465.92s)
also consider the fact that we need a
[41:08] (2468.72s)
template for how to make these bubbles,
[41:10] (2470.88s)
how to make these isolated environments,
[41:13] (2473.12s)
which more technically takes the form of
[41:15] (2475.04s)
a docker file. So I kind of gave it some
[41:17] (2477.12s)
direction. I said, "Hey, look into this
[41:18] (2478.80s)
docker file thing for me. This is what
[41:20] (2480.32s)
cloud is telling me that it needs to run
[41:22] (2482.08s)
cloud code. You should probably like
[41:24] (2484.64s)
think about that a little at least. And
[41:26] (2486.64s)
I want you to start showing me your
[41:28] (2488.24s)
thought process in code. Whenever it's
[41:30] (2490.40s)
coding, I'm reviewing what is coding. If
[41:32] (2492.16s)
I see it's going off track, I'll stop
[41:33] (2493.60s)
it. And at the same time, I'll myself as
[41:35] (2495.84s)
a human gain more context on the code
[41:37] (2497.84s)
And this is also another reason why
[41:39] (2499.12s)
being technical is an advantage is
[41:41] (2501.92s)
because you can run a prompt like this.
[41:43] (2503.12s)
I can't run a prompt like this and look
[41:44] (2504.24s)
at the code and be like, that's good. We
[41:46] (2506.08s)
agree on good code. I don't know what
[41:47] (2507.76s)
that is. But the powerful, as I
[41:50] (2510.72s)
mentioned before, I've never used
[41:51] (2511.84s)
Daytona before, but I background
[41:57] (2517.20s)
and if something looks outrageously
[41:58] (2518.88s)
wrong, I can stop it. So, I see it, you
[42:01] (2521.68s)
know, creating a sandbox in JavaScript.
[42:05] (2525.28s)
I see it passing down some variables.
[42:08] (2528.80s)
I see it starting the sandbox.
[42:11] (2531.84s)
I see it testing if cloud code exists in
[42:14] (2534.32s)
there. I see it trying to make a
[42:16] (2536.96s)
directory for the generated app and then
[42:18] (2538.80s)
I see it writing exactly the first thing
[42:22] (2542.24s)
that we have written which is the first
[42:24] (2544.64s)
thing we did was make it run write a
[42:26] (2546.40s)
single piece of code that can generate
[42:27] (2547.68s)
code so it actually copies that straight
[42:30] (2550.00s)
into the sandbox and tries to execute it
[42:32] (2552.48s)
which is what I see here and it's
[42:34] (2554.40s)
starting to generate a welcome page yeah
[42:36] (2556.72s)
so it basically creates a script that
[42:38] (2558.16s)
says generate me a nextjs great
[42:40] (2560.40s)
that says hello world and then it'll
[42:42] (2562.24s)
generate it and then let's see Check
[42:44] (2564.48s)
what was created. This is pretty good.
[42:47] (2567.04s)
Would you like to proceed? Yes, let's
[42:49] (2569.44s)
just do it. I want ideally it's doing
[42:52] (2572.08s)
both of these because I do want I think
[42:54] (2574.24s)
both approaches could work. And this is
[42:56] (2576.24s)
another good thing. It came to me with
[42:57] (2577.52s)
two things. Test the script directory.
[42:59] (2579.92s)
Create the test Daytona integration
[43:02] (2582.40s)
script. Run the test scripts to validate
[43:04] (2584.56s)
Daytona verify. Great. Yeah, pretty
[43:06] (2586.88s)
excited actually because this is getting
[43:08] (2588.72s)
into like
[43:09] (2589.36s)
this is really cool. This is getting
[43:10] (2590.72s)
into like some like senior architect
[43:12] (2592.40s)
like senior engineer like system design
[43:14] (2594.24s)
architecting.
[43:15] (2595.12s)
So did you want to try with cursor real
[43:17] (2597.68s)
the screenshot? Yeah. Let's give it this
[43:20] (2600.56s)
copy. I just want to make sure that this
[43:22] (2602.48s)
is actually the page that I wanted to
[43:24] (2604.56s)
edit. Yeah. Handle generate. I want you
[43:30] (2610.96s)
make this landing page look more like
[43:35] (2615.36s)
Lovable's actual landing page. And so
[43:38] (2618.88s)
let's just give it a real landing page.
[43:41] (2621.76s)
I see that it is having difficulties
[43:43] (2623.76s)
with Daytona. We could intervene here
[43:46] (2626.40s)
and tell it to scope down even more. I
[43:48] (2628.56s)
see it failed to start a sandbox. So we
[43:50] (2630.56s)
could say, "Hey, I want you to just
[43:51] (2631.76s)
focus on starting a sandbox." Should be
[43:53] (2633.84s)
pretty easy. We'll see if it continues
[43:55] (2635.92s)
to fail. You know, it said the test
[43:58] (2638.00s)
failed. It sent three agents in parallel
[44:00] (2640.96s)
to use a bunch of my money to go and
[44:03] (2643.52s)
figure out the issue. And then now it's
[44:06] (2646.88s)
removed my friendly comment. Fine,
[44:09] (2649.36s)
whatever. And then it's adding some more
[44:11] (2651.76s)
code. So great, it's finally getting
[44:13] (2653.60s)
back to work after making me wait for a
[44:15] (2655.68s)
good 5 minutes. Meanwhile, 03 has also
[44:18] (2658.72s)
promised me that we have a better
[44:20] (2660.48s)
landing page now. So I'm just going to
[44:22] (2662.16s)
go accept all on here, close this thing
[44:24] (2664.56s)
again, and then actually see if we do
[44:27] (2667.28s)
have a better landing page. Where are
[44:28] (2668.80s)
you, local host?
[44:29] (2669.84s)
What the
[44:30] (2670.72s)
Oh my god. First of all, this is a war
[44:33] (2673.68s)
crime to have this emoji here.
[44:37] (2677.04s)
Okay, thank you. Center thumb below the
[44:41] (2681.44s)
text input.
[44:45] (2685.28s)
I like it. And then can you make the you
[44:47] (2687.68s)
just make the other one tiny like 1x?
[44:51] (2691.04s)
Which one?
[44:52] (2692.24s)
Very small on the actual site. So it's
[44:54] (2694.32s)
telling me that
[44:57] (2697.36s)
time that the core functionality works
[45:00] (2700.00s)
generated a sandbox with this.
[45:02] (2702.80s)
So tell me how I can preview
[45:09] (2709.04s)
the dev project inside the sandbox with
[45:13] (2713.60s)
the ID.
[45:15] (2715.52s)
Oh, not lovable. Sorry. With this ID.
[45:19] (2719.12s)
Cool. And let's just accept all of 03's
[45:21] (2721.52s)
changes again. be optimistic. Okay.
[45:24] (2724.00s)
Like, yeah, it just needs to be like 10
[45:25] (2725.76s)
times larger, but we Okay, we're getting
[45:28] (2728.48s)
there. Good job. Lovable's design is
[45:30] (2730.80s)
actually pretty nice. This is just very
[45:32] (2732.80s)
depressing. But we got the gradient.
[45:34] (2734.40s)
Actually, the gradient is the same. It's
[45:36] (2736.24s)
just so small and there's just random
[45:38] (2738.16s)
gradient here and here. It's trying to
[45:39] (2739.92s)
run it and it is failing. But let's see.
[45:43] (2743.84s)
So, it's telling me it worked, but I
[45:46] (2746.88s)
have no way to confirm. And this is
[45:49] (2749.20s)
apparently cloud code is telling us that
[45:51] (2751.28s)
we have a bubble and inside of that
[45:53] (2753.12s)
bubble we do have a next.js project. The
[45:55] (2755.84s)
only thing is I can't view inside of
[45:57] (2757.68s)
that bubble. And so now we're trying to
[45:59] (2759.60s)
figure out how to view inside of that
[46:01] (2761.28s)
bubble. So currently we're debugging a
[46:03] (2763.12s)
lot of things about does the bubble
[46:04] (2764.64s)
actually get spawned? Is there a nextjs
[46:07] (2767.20s)
project in there? And how can I look at
[46:09] (2769.04s)
that nextjs project? After we get that
[46:11] (2771.20s)
sorted out, we're going to go back,
[46:12] (2772.88s)
inject our agent again, which is
[46:14] (2774.64s)
actually just cloud code SDK, and tell
[46:16] (2776.72s)
it to build it what website we want.
[46:19] (2779.76s)
And then after that, we're going to hook
[46:21] (2781.12s)
it back up to our website. And then
[46:23] (2783.04s)
we're going to have a website that
[46:24] (2784.72s)
creates a bubble with cloud code inside
[46:26] (2786.72s)
of it. And cloud code can go crazy and
[46:28] (2788.48s)
code up our website. It will expose that
[46:30] (2790.96s)
website so that people can see it from
[46:32] (2792.64s)
the outside. And then we'll be able to
[46:34] (2794.24s)
see the issue.
[46:35] (2795.60s)
Amazing.
[46:36] (2796.00s)
Oh, not the issue. The
[46:36] (2796.88s)
Do you want to check your texts? I sent
[46:39] (2799.68s)
you a gradient that you can use as the
[46:41] (2801.20s)
background. I think it'll look really
[46:42] (2802.40s)
good. Can you please make this image the
[46:45] (2805.04s)
background of the web app that we've
[46:47] (2807.36s)
created? This is going to be behind the
[46:49] (2809.52s)
text input field. And then for the text
[46:52] (2812.00s)
input field, keep it exactly the same. I
[46:54] (2814.08s)
just want you to make it really dark,
[46:56] (2816.00s)
like almost black, so that you can
[46:58] (2818.72s)
hardly see through it. So this image
[47:00] (2820.72s)
should be the background and then yeah,
[47:03] (2823.76s)
make it darker behind the input field
[47:06] (2826.08s)
with white text as you type.
[47:08] (2828.88s)
Nice. So, we'll let 03 cook on that. But
[47:11] (2831.28s)
let's get back to the main project. I
[47:12] (2832.80s)
see it and this is an issue that it
[47:14] (2834.24s)
continues to like to do where it tries
[47:15] (2835.84s)
to run it, but obviously it's shell
[47:18] (2838.32s)
inside of itself is, you know, like
[47:20] (2840.64s)
doesn't live long. So, I'm going to tell
[47:22] (2842.64s)
it to stop and I'm just going to run it
[47:24] (2844.00s)
myself. And then, okay, it failed
[47:27] (2847.04s)
because it cannot find it. So, where is
[47:30] (2850.40s)
this npxtx scripts scripts? Where is the
[47:34] (2854.32s)
script?
[47:36] (2856.24s)
So I actually have to CD into lovable UI
[47:39] (2859.52s)
and then run this. And so it's created a
[47:42] (2862.48s)
sandbox. Okay, great. It's creating an
[47:44] (2864.16s)
next.js project. Let's see if it
[47:45] (2865.84s)
actually does that. And so I'm running
[47:48] (2868.00s)
the script that Cloud Code wrote me to
[47:50] (2870.40s)
see. We can look for public. Create
[47:53] (2873.44s)
sandbox preview. I think it does have
[47:56] (2876.24s)
public true. Yeah, it does. Create next
[48:01] (2881.12s)
dayu.work.
[48:02] (2882.96s)
So, I mean, this actually does look
[48:05] (2885.36s)
pretty much like, let's see. This is
[48:09] (2889.36s)
saying, and I'm going to use this as a
[48:11] (2891.84s)
text input, but let's see. It's saying,
[48:15] (2895.36s)
what is our sandbox ID? Important
[48:18] (2898.64s)
sandbox ID is this thing. So, sandbox,
[48:21] (2901.76s)
that doesn't look like a sandbox ID.
[48:24] (2904.56s)
Sandbox ID. Okay, maybe it is. Is there
[48:27] (2907.20s)
any way I can SSH into this sandbox? So
[48:30] (2910.16s)
to do some more complicated debugging.
[48:33] (2913.36s)
So we have a bubble now.
[48:36] (2916.24s)
Okay. Okay. Okay. It does seem like we
[48:39] (2919.20s)
are spinning up these bubbles. Inside of
[48:41] (2921.68s)
the bubbles there do seem to be some
[48:44] (2924.16s)
resemblance of a website. I'm not very
[48:46] (2926.16s)
familiar with Nex.js. I guess we can see
[48:48] (2928.16s)
the app and see like what's in here.
[48:50] (2930.24s)
Okay. We have page.tsx.
[48:53] (2933.60s)
Okay. Yeah. I think there is indeed a
[48:55] (2935.84s)
website on the bubble inside of the
[48:57] (2937.52s)
Daytona server. But the problem is we're
[48:59] (2939.44s)
struggling peeking into it.
[49:00] (2940.80s)
Yeah. Okay. So this is the sandbox
[49:02] (2942.40s)
running. This is now
[49:05] (2945.36s)
we want to peek into this bubble. So we
[49:08] (2948.08s)
do have confirmation that there is you
[49:10] (2950.88s)
know. Okay. I still can't open the
[49:13] (2953.36s)
websites.
[49:14] (2954.88s)
I am getting 503
[49:17] (2957.84s)
service temp unavailable.
[49:21] (2961.76s)
Can you do some deep research
[49:26] (2966.16s)
on why this is the case? I am running
[49:32] (2972.40s)
what script am I running? Test Daytona
[49:34] (2974.72s)
simple. Daytona simple.
[49:38] (2978.24s)
I noticed that
[49:41] (2981.28s)
inside what did I notice? I noticed this
[49:43] (2983.44s)
the sandbox ID seems to be different
[49:46] (2986.88s)
from the ones we are getting. For
[49:50] (2990.96s)
example, on this website, the sandbox
[49:53] (2993.60s)
says that this is the ID which the ID
[49:57] (2997.60s)
seems to be something like this from the
[50:02] (3002.40s)
docs. But we are getting UYU ids like
[50:08] (3008.40s)
what am I getting? I'm getting something
[50:10] (3010.56s)
like this. Oh, wait. Yeah.
[50:13] (3013.28s)
So, yeah, that was an observation I
[50:14] (3014.96s)
made. Please search the web think. Oh,
[50:19] (3019.84s)
yeah. Cloud code has specific reserved
[50:22] (3022.48s)
key terms for how hard you want it to
[50:24] (3024.24s)
think. I'm pretty sure the the highest
[50:26] (3026.80s)
level of thinking is literally ultra
[50:28] (3028.48s)
think. I don't know. Maybe they were
[50:29] (3029.76s)
just like having fun. I'm pretty sure
[50:32] (3032.16s)
clad code ultra think. Yeah. Yeah. It's
[50:35] (3035.60s)
actually like the way to tell it to use
[50:37] (3037.92s)
the most juice. So, I'm just going to
[50:39] (3039.60s)
So, this be $10.
[50:40] (3040.72s)
Yeah. Basically, it'll just use
[50:42] (3042.88s)
as much tokens as it can possibly use
[50:45] (3045.52s)
basically and try to figure out the
[50:47] (3047.04s)
issue. So, if Daytona's documentation is
[50:50] (3050.32s)
right,
[50:51] (3051.60s)
this indeed should be something that
[50:54] (3054.16s)
gives us a URL that we should be able to
[50:56] (3056.48s)
see inside the bubble. So, we were able
[50:58] (3058.08s)
to confirm that a bubble was created,
[50:59] (3059.84s)
code was being written there, but we
[51:02] (3062.16s)
can't see inside the bubble. And that
[51:03] (3063.76s)
was because cloud code did not read
[51:06] (3066.16s)
enough documentation just like the
[51:08] (3068.32s)
average engineer.
[51:09] (3069.44s)
Right. Right. Right. Right. Right.
[51:10] (3070.96s)
So I had to read some documentation
[51:13] (3073.20s)
myself and I found out that
[51:15] (3075.52s)
it's not using the preview link.
[51:18] (3078.24s)
It is not using get preview link which
[51:20] (3080.24s)
conveniently returns to you a URL and
[51:23] (3083.04s)
the token to access it. Let's run that
[51:26] (3086.48s)
test preview URLs. Okay. Now it likes to
[51:29] (3089.12s)
break things down. It broke itself down
[51:30] (3090.72s)
into smaller tests. So now it's creating
[51:33] (3093.12s)
another test to test if this previewed
[51:34] (3094.96s)
URL thing works as it promises.
[51:37] (3097.28s)
Right. But once again, it's running this
[51:40] (3100.16s)
thing inside of the bash of itself. I'm
[51:43] (3103.44s)
gonna run the script myself.
[51:46] (3106.96s)
Creating sandbox creating next.js app.
[51:50] (3110.56s)
Then let's just read what the script
[51:53] (3113.28s)
So now we created another bubble. The
[51:55] (3115.28s)
sandbox is the bubble that we were
[51:56] (3116.80s)
talking about, the isolated environment.
[51:58] (3118.64s)
And then we're going to have it create
[52:00] (3120.88s)
me a next.js app inside of the app.
[52:03] (3123.36s)
It's going to go and create a custom
[52:04] (3124.88s)
page at preview. It's going to install
[52:06] (3126.32s)
dependencies. And then it's going to
[52:07] (3127.76s)
start the dev server, which is what
[52:09] (3129.60s)
we're trying to peek into,
[52:10] (3130.88s)
right?
[52:11] (3131.68s)
Amazing.
[52:12] (3132.16s)
So, um,
[52:12] (3132.80s)
and then we'll get the preview link to
[52:14] (3134.24s)
that server.
[52:15] (3135.60s)
And that's what we'll be able to see.
[52:16] (3136.80s)
And ideally, we could render that in the
[52:18] (3138.48s)
site itself in the front end of the
[52:20] (3140.56s)
lovable site.
[52:22] (3142.08s)
Okay. Amazing. And that's probably like
[52:23] (3143.92s)
something similar to what how they do
[52:26] (3146.56s)
I mean, I don't know how they do it, but
[52:28] (3148.48s)
Oh, it's here.
[52:30] (3150.64s)
this is the website. Hey.
[52:32] (3152.32s)
And so they're telling me that this dash
[52:34] (3154.80s)
preview is a website that it built.
[52:38] (3158.24s)
Preview works.
[52:39] (3159.44s)
Let's go.
[52:40] (3160.72s)
Okay. So now we can finally look into
[52:43] (3163.68s)
the sandbox. So we have all of our
[52:45] (3165.76s)
pieces together. Now we have a way to
[52:48] (3168.08s)
create bubbles on someone else's cloud.
[52:50] (3170.80s)
We have a way to
[52:52] (3172.48s)
write code inside of that cloud. And we
[52:54] (3174.72s)
have a way to trigger it through our
[52:57] (3177.12s)
website. So let's just ask cloud code to
[52:59] (3179.52s)
put it all together. And so we have
[53:03] (3183.04s)
great this one did indeed work. So we're
[53:06] (3186.32s)
just going to go ahead and say
[53:09] (3189.44s)
wonderful job.
[53:12] (3192.24s)
You sounded white when you said that.
[53:14] (3194.88s)
Wonderful job. Sorry.
[53:16] (3196.24s)
Wonderful job. No, it did a great job.
[53:18] (3198.64s)
Wonderful job, Claude. We now can
[53:22] (3202.40s)
successfully
[53:24] (3204.32s)
look at the NextJS
[53:27] (3207.76s)
project. And so actually, hold on. Okay.
[53:30] (3210.48s)
Well, anyways, so to reiterate what just
[53:34] (3214.24s)
happened, we finally were able to peek
[53:36] (3216.08s)
into the sandboxes, which is the bubbles
[53:38] (3218.64s)
that we were talking about this whole
[53:40] (3220.08s)
And you blamed Atono when it was
[53:41] (3221.60s)
probably Cloud Code's fault, maybe.
[53:43] (3223.52s)
Yeah. Yeah. Yeah, it was probably Claude
[53:44] (3224.96s)
Code's fault. Daytona actually had
[53:46] (3226.64s)
decent documentation. I found it pretty
[53:48] (3228.32s)
quick. There was a function that Claude
[53:49] (3229.92s)
Code refused to use, probably because it
[53:51] (3231.76s)
did not find the right thing to read.
[53:53] (3233.60s)
So, once again, that's, you know, a
[53:55] (3235.76s)
context management mistake on my end to
[53:57] (3237.68s)
be honest. So, we found that though. We
[53:59] (3239.84s)
did some digging. We gave Claude the
[54:01] (3241.68s)
context and it fixed it immediately with
[54:03] (3243.76s)
the last script that it ran which was
[54:06] (3246.00s)
what was the script? Oops. The script
[54:08] (3248.64s)
was mpxtscripts.
[54:11] (3251.92s)
Preview. So I'm going to I'm currently
[54:14] (3254.64s)
updating the markdown of cloud.md.
[54:17] (3257.60s)
Remember this is the kind of memory that
[54:19] (3259.36s)
it has attached to every prompt that it
[54:22] (3262.24s)
kind of gives it like structure. And
[54:25] (3265.20s)
this is, you know, how earlier we were
[54:26] (3266.96s)
mentioning how it's good to give the
[54:28] (3268.96s)
agent like a picture of the final output
[54:32] (3272.00s)
and kind of like what has happened so
[54:33] (3273.76s)
far. This is kind of like a conversation
[54:35] (3275.20s)
history. I'm updating it a little bit so
[54:37] (3277.12s)
that we can type less every time we
[54:39] (3279.68s)
submit a prompt. So I said, you know,
[54:41] (3281.68s)
the goal is to make a lovable clone. We
[54:43] (3283.44s)
want to use cloud code SDK. We have a
[54:45] (3285.20s)
website that takes in a prompt. It uses
[54:47] (3287.20s)
cloud code SDK to write code, but
[54:48] (3288.96s)
currently it modifies the website by
[54:50] (3290.96s)
adding it as a page. We want to make
[54:52] (3292.88s)
this happen in an isolated environment.
[54:55] (3295.44s)
So now we have created a way to create
[54:57] (3297.28s)
sandboxes which is the bubble using
[54:59] (3299.52s)
Daytona to preview them and preview
[55:01] (3301.76s)
them. Get preview what is it called? Get
[55:04] (3304.96s)
preview.
[55:05] (3305.20s)
You have it on your clipboard too.
[55:06] (3306.40s)
Yeah. Using the get preview link
[55:10] (3310.40s)
function. The script confirms this.
[55:14] (3314.56s)
Okay. So this is our progress so far.
[55:17] (3317.52s)
I'm going to save it to its memory. I'm
[55:19] (3319.28s)
going to go back to good old cloud code
[55:21] (3321.84s)
and I'm going to say wonderful job. We
[55:24] (3324.32s)
now have a successful We can now
[55:26] (3326.16s)
successfully look at the next.js
[55:28] (3328.80s)
project. It does have a preview page.
[55:32] (3332.16s)
Scripts.js worked perfectly. Oh yeah,
[55:35] (3335.68s)
and this is another thing we kept on
[55:39] (3339.28s)
noticing that it tries to run the script
[55:41] (3341.36s)
but it can't like do anything. So don't
[55:44] (3344.96s)
try to run the script with your own bash
[55:49] (3349.60s)
tool. Write the scripts
[55:53] (3353.36s)
going forward. And this is probably like
[55:55] (3355.04s)
project like let's see like what is this
[55:58] (3358.56s)
preferences.
[56:00] (3360.56s)
Don't try to run the script on your own
[56:02] (3362.32s)
pouch. Write the script and tell me how
[56:05] (3365.36s)
to execute it asking me for its outputs
[56:10] (3370.80s)
instead. So let's just leave that there.
[56:14] (3374.40s)
It does have a preview page scripts. The
[56:18] (3378.24s)
script worked perfectly. Now I want you
[56:22] (3382.16s)
to go back and make it such
[56:26] (3386.88s)
that I can create a Daytona sandbox and
[56:32] (3392.72s)
using cloud code SDK
[56:36] (3396.56s)
build a custom website based on a prompt
[56:41] (3401.92s)
that I pass in this. Let's keep this as
[56:45] (3405.92s)
a script for now, but we will implement
[56:50] (3410.24s)
it into our website as soon as we
[56:54] (3414.00s)
confirm that it works.
[56:56] (3416.72s)
Amazing.
[56:57] (3417.28s)
Great. It's created a script that
[56:58] (3418.64s)
creates a Daytona sandbox, installs
[57:01] (3421.12s)
Cloud Code, generates a website,
[57:04] (3424.24s)
installs the dependencies, and gives me
[57:06] (3426.88s)
the preview link. That sounds perfect.
[57:10] (3430.32s)
That supports Markdown support and dark
[57:12] (3432.16s)
theme. You know, that's a great idea.
[57:14] (3434.24s)
Let's just do this
[57:16] (3436.56s)
basic usage. And then notice that it
[57:18] (3438.96s)
wants me I told it that I want to run
[57:20] (3440.64s)
the script myself. So, it gave me some
[57:22] (3442.08s)
options to run the script. And that's a
[57:23] (3443.60s)
great idea. Thank you Claude Code for
[57:25] (3445.60s)
that. I will go ahead and do that.
[57:28] (3448.80s)
Create a blog website with markdown
[57:30] (3450.80s)
support and a dark command is required.
[57:32] (3452.72s)
Let's see. Cloud code running cloud code
[57:35] (3455.76s)
command is required. Sandbox is still
[57:38] (3458.16s)
running for debugging. This is going to
[57:41] (3461.52s)
be a hassle to debug because oops.
[57:45] (3465.52s)
Wait, is that permissions issue or no?
[57:47] (3467.92s)
So, we don't know cuz this is uh the
[57:50] (3470.72s)
only error that is thrown command is
[57:52] (3472.72s)
required. We can go ahead and run this.
[57:55] (3475.92s)
I have a good feeling that we can get
[57:58] (3478.64s)
through this though. So I tried to run
[58:02] (3482.72s)
the script asking it to build me a what
[58:08] (3488.56s)
did I ask it to build? Uh blog website.
[58:13] (3493.04s)
This is the output.
[58:16] (3496.80s)
How can we debug the issue? Remember the
[58:22] (3502.16s)
sandbox which is the bubble is still
[58:25] (3505.28s)
alive and I can SSH into it with a
[58:30] (3510.08s)
terminal.
[58:31] (3511.68s)
Oops, pasted that in. Okay, so now it
[58:34] (3514.80s)
has the error. It will either give me
[58:37] (3517.12s)
directions to debug or it will try and
[58:39] (3519.68s)
solve the issue. So the error is command
[58:41] (3521.84s)
is required suggest there's an issue
[58:43] (3523.12s)
with how we're executing the command.
[58:45] (3525.04s)
Let me do a debugging script. Okay, I
[58:47] (3527.60s)
think I know the issue. Once again, I
[58:50] (3530.40s)
might have to pass down this to claude
[58:52] (3532.40s)
code. Let's actually just tell it.
[58:55] (3535.36s)
I don't think you
[58:56] (3536.16s)
need to debugging script first. I want
[59:00] (3540.88s)
you to read this documentation and make
[59:04] (3544.32s)
sure you are using Daytona properly. And
[59:08] (3548.48s)
so this is actually a common issue with
[59:10] (3550.80s)
the fact that the LLM can browse the
[59:14] (3554.40s)
web. But since Daytona and all these new
[59:17] (3557.84s)
companies are writing things that are
[59:20] (3560.16s)
often changing and since they're so new,
[59:23] (3563.20s)
you know, Daytona,
[59:25] (3565.44s)
if they don't follow strict industry
[59:27] (3567.52s)
standards or like whatever the training
[59:29] (3569.76s)
data that cloud code is on, it might
[59:32] (3572.08s)
have like enthropic or cloud code might
[59:34] (3574.80s)
default to like what it thinks is right
[59:37] (3577.04s)
oftent times. and just go back to like
[59:39] (3579.92s)
writing broken code because it thinks
[59:41] (3581.84s)
that's what it should look like and
[59:43] (3583.52s)
Daytona is not following that or
[59:46] (3586.40s)
something. So yeah, we found the issue
[59:48] (3588.16s)
already. We our hypothesis was correct.
[59:50] (3590.64s)
It was not doing execute command
[59:52] (3592.72s)
properly which makes sense because our
[59:55] (3595.04s)
error was actually something like
[59:56] (3596.24s)
command is required. So hopefully this
[59:58] (3598.96s)
will fix it and we can run this again.
[60:00] (3600.88s)
We can check on the design now. accept
[60:03] (3603.12s)
these changes instantly.
[60:05] (3605.44s)
And drum roll, please. Oh. Oh, god.
[60:09] (3609.76s)
Nope. 404 gradient.png. Can you please
[60:14] (3614.64s)
Let's see if it's telling me to do
[60:16] (3616.16s)
anything. Do I need to restart you?
[60:20] (3620.08s)
No. No. No. Because serves everything in
[60:23] (3623.36s)
public. The background should not
[60:24] (3624.48s)
automatically load once it's there.
[60:26] (3626.48s)
Create a public folder. Okay. It doesn't
[60:28] (3628.96s)
exist already. Drop the provided image.
[60:31] (3631.28s)
Okay. So, it's telling me to create a
[60:33] (3633.92s)
public folder in here. New folder.
[60:37] (3637.52s)
Public. And then move this into here.
[60:42] (3642.48s)
Now, will you work? No. Okay. At drop
[60:46] (3646.80s)
the provided image because the next js
[60:50] (3650.00s)
serves everything in public on the site
[60:51] (3651.60s)
folder, the background will now load
[60:52] (3652.80s)
automatically.
[60:54] (3654.40s)
It's not.
[60:56] (3656.88s)
it is not. Oh, wait. Gradient is in
[61:00] (3660.40s)
public. Yeah.
[61:02] (3662.00s)
I still don't see it. Slashpublic at
[61:06] (3666.48s)
slashpublic. I put the image in.
[61:11] (3671.12s)
Yeah. Yeah, I really don't see it. Okay,
[61:12] (3672.88s)
let's see.
[61:13] (3673.28s)
Maybe the gradient design is over the
[61:15] (3675.52s)
image.
[61:16] (3676.56s)
Oh, yeah.
[61:17] (3677.28s)
I'm not sure. Maybe that is a good idea.
[61:19] (3679.52s)
But back to this exciting thing. It says
[61:22] (3682.80s)
that the air messages will be more
[61:25] (3685.04s)
explicit. Great. Cloud code installation
[61:27] (3687.12s)
before running. Great. And then it will
[61:29] (3689.28s)
run. So let's try to run this thing
[61:33] (3693.12s)
again. Let's go.
[61:34] (3694.56s)
Come on.
[61:35] (3695.44s)
Yeah. Come on. Come on.
[61:37] (3697.12s)
So ideally, oh website generation
[61:39] (3699.68s)
failed. Cannot find package import from.
[61:43] (3703.60s)
Okay. So that means let's see. It says
[61:45] (3705.84s)
running cloud code to generate but it
[61:47] (3707.68s)
says installing cloud code SDK. Let's
[61:50] (3710.96s)
see exactly how it is installing cloud
[61:53] (3713.36s)
code SDK because something is definitely
[61:56] (3716.32s)
not installed properly. Generate website
[61:58] (3718.88s)
simple and generate website in sandbox.
[62:01] (3721.04s)
Which one am I running? Generate website
[62:03] (3723.20s)
in sandbox
[62:05] (3725.20s)
undefined. It definitely failed to
[62:07] (3727.76s)
install this somehow.
[62:09] (3729.68s)
Install
[62:11] (3731.28s)
cloud code.
[62:13] (3733.20s)
Interesting.
[62:13] (3733.76s)
So let's see. This is one way we can
[62:16] (3736.24s)
debug this quite simply by going into
[62:18] (3738.96s)
here. Oops. I mean I guess Okay. Let's
[62:21] (3741.92s)
see. Sandbox ID is this one. We can go
[62:25] (3745.36s)
ahead actually and go into Daytona.
[62:28] (3748.72s)
Sandbox started with F9, right? Nope.
[62:30] (3750.80s)
F5. So, we can just go connect here and
[62:34] (3754.08s)
we can see what happens when we try to
[62:36] (3756.40s)
run the command that failed, which is
[62:38] (3758.72s)
sandbox.
[62:40] (3760.56s)
Oops. No, it's going to be here. Let's
[62:43] (3763.44s)
see if this works. Okay, I'm on the
[62:45] (3765.12s)
sandbox. I'm in the bubble right now. I
[62:46] (3766.88s)
only have a terminal. And I'm gonna go
[62:49] (3769.04s)
ahead and feed cloud code some more
[62:51] (3771.12s)
context on what exists inside of the
[62:53] (3773.44s)
bubble to helpfully help it debug what
[62:55] (3775.84s)
is going on.
[62:56] (3776.64s)
Amazing.
[62:57] (3777.28s)
Okay, I'm just gonna go and take all
[62:59] (3779.44s)
this stuff and give it the cloud code as
[63:01] (3781.52s)
well. This is the error. It seems like
[63:05] (3785.04s)
cloud code is not being imported or
[63:09] (3789.60s)
downloaded properly. I also sshed into
[63:13] (3793.92s)
the sandbox and did some snooping.
[63:18] (3798.40s)
This is some more context to help you
[63:23] (3803.36s)
debug. So, this is telling cloud code
[63:25] (3805.84s)
that there's more information available.
[63:27] (3807.84s)
It got a little further, right?
[63:29] (3809.44s)
Uh, no. I still think it's the same
[63:31] (3811.84s)
cloud code. Okay. No, no, no. We now
[63:34] (3814.40s)
have cloud code process exited. So, we
[63:36] (3816.80s)
have cloud code now. I think this might
[63:39] (3819.36s)
be because it's sandbox is blocking out
[63:42] (3822.48s)
perhaps. I think there's something we
[63:44] (3824.32s)
can do to debug this. How do can I
[63:48] (3828.64s)
easily check if a sandbox has access to
[63:52] (3832.72s)
the internet? Well, I can just ping
[63:54] (3834.80s)
Google. Oh, no. It does have internet
[63:57] (3837.36s)
access. Okay. So, my initial thought was
[63:59] (3839.92s)
that maybe the bubble doesn't have
[64:01] (3841.28s)
internet access. It needs internet
[64:02] (3842.96s)
access if you want to run cloud code.
[64:04] (3844.96s)
You ping Google and it does have access.
[64:07] (3847.04s)
Yeah, I can also ping api.anthropic.com
[64:11] (3851.76s)
and see if this one Yeah, this one is
[64:13] (3853.60s)
getting a response.
[64:14] (3854.72s)
What does ping? Ping means just like
[64:16] (3856.16s)
check if it's
[64:16] (3856.88s)
Yeah, it just pokes the website and sees
[64:18] (3858.40s)
if it like gets a response. Cloud code
[64:20] (3860.72s)
exited with bear one and let's see.
[64:24] (3864.64s)
Nope. Wow. I now so this is the drawback
[64:28] (3868.40s)
of getting AI to do everything for you.
[64:31] (3871.28s)
I have no idea what is wrong or I can
[64:34] (3874.24s)
only like believe that
[64:36] (3876.24s)
only context manage.
[64:37] (3877.44s)
I can't create my own context. I told it
[64:39] (3879.76s)
look use the right documentation and
[64:42] (3882.00s)
it's reading the web again. So hopefully
[64:44] (3884.40s)
this time it'll figure something out
[64:46] (3886.96s)
that actually works and we can have
[64:49] (3889.04s)
lovable clone. Cloud code has actually
[64:51] (3891.36s)
used 70% of its context. I'm going to go
[64:53] (3893.60s)
ahead and compact this since I don't
[64:55] (3895.60s)
care about the specifics because if you
[64:59] (3899.12s)
remember we are trying to create a proof
[65:02] (3902.72s)
of concept script that uses Daytona to
[65:05] (3905.44s)
spin up an isolated environment where we
[65:09] (3909.12s)
want to run cloud code to create a
[65:11] (3911.28s)
next.js website.
[65:13] (3913.76s)
So this is a broadstroke. Currently
[65:15] (3915.92s)
we've been failing and a lot of the time
[65:17] (3917.84s)
is because we are not implementing code
[65:20] (3920.56s)
execution
[65:22] (3922.08s)
properly inside the sandbox properly
[65:26] (3926.80s)
with Daytona's
[65:30] (3930.56s)
Let's create another script. But going
[65:32] (3932.40s)
forward, I want you to
[65:35] (3935.44s)
create the script inside of Daytona and
[65:38] (3938.72s)
I want you to execute it. And I also
[65:41] (3941.92s)
want you to
[65:44] (3944.16s)
install and log if you installed it by
[65:48] (3948.48s)
checking using ls in terms of where it
[65:52] (3952.48s)
should be installed and do not install
[65:55] (3955.36s)
dependencies globally.
[65:57] (3957.84s)
Also, I want the script to be able to
[65:59] (3959.92s)
take in a sandbox ID. So, if it's
[66:02] (3962.80s)
already spinning up a sandbox that
[66:04] (3964.88s)
exists, don't create a new one. Just use
[66:06] (3966.88s)
the sandbox that we already have. And so
[66:09] (3969.84s)
I'm going to go ahead and once again
[66:11] (3971.20s)
feed it some Daytona Docs process
[66:14] (3974.24s)
execution. Running commands. Yeah,
[66:16] (3976.48s)
running commands and code execution.
[66:18] (3978.56s)
Let's see. Run code.
[66:21] (3981.76s)
Run commands.
[66:23] (3983.84s)
I am going to feed it these docs. And
[66:26] (3986.64s)
I'm going to say
[66:29] (3989.36s)
I want you to actually create the file
[66:31] (3991.92s)
inside of Daytona
[66:34] (3994.64s)
and not just pass in the whole JS as
[66:38] (3998.80s)
code to execute.
[66:41] (4001.04s)
Okay, let's see if this would be a bit
[66:43] (4003.36s)
better. So now I'm just going to try
[66:45] (4005.68s)
again and I want you to make what's a
[66:48] (4008.24s)
good website idea? website idea. Please
[66:50] (4010.48s)
make a site that lets me upload an image
[66:54] (4014.00s)
and I can resize it or crop it by
[66:58] (4018.00s)
adjusting a slider or some [ __ ]
[66:59] (4019.44s)
Let's do it. Make me a site that lets me
[67:01] (4021.44s)
upload an image and allows me to resize
[67:03] (4023.60s)
it. And so great. Currently, we have a
[67:07] (4027.12s)
script that
[67:09] (4029.44s)
runs generate website. And now it's
[67:11] (4031.20s)
going to try to generate that website.
[67:13] (4033.04s)
So this is super exciting. Once we
[67:15] (4035.36s)
confirm that this works, we're just
[67:16] (4036.72s)
going to hook it up so that our lovable
[67:18] (4038.56s)
clone website runs. This
[67:20] (4040.08s)
will look like Lovable.
[67:21] (4041.36s)
Yeah. Yeah. Where's our Lovable website
[67:23] (4043.12s)
clone? We haven't seen this in a while.
[67:24] (4044.80s)
This bad boy that we spent two hours on.
[67:27] (4047.04s)
We're good, dude. We're hitting the home
[67:28] (4048.32s)
stretch here.
[67:29] (4049.12s)
That's I currently don't see the
[67:32] (4052.88s)
background image. I think this might be
[67:37] (4057.76s)
because you are covering it with other
[67:42] (4062.40s)
stuff. the image is replacing that other
[67:44] (4064.72s)
stuff.
[67:45] (4065.12s)
Yeah. Make sure that the image is shown
[67:49] (4069.20s)
and nothing is on top of
[67:52] (4072.24s)
besides the UI of the
[67:54] (4074.32s)
beside
[67:56] (4076.24s)
the text input field, right?
[67:57] (4077.52s)
The text input field.
[68:01] (4081.76s)
Amazing. Okay. Great. And this thing
[68:03] (4083.68s)
also just finished generating a website.
[68:06] (4086.56s)
And so now it's creating some link here.
[68:09] (4089.60s)
Ideally.
[68:10] (4090.24s)
Yeah. Yeah. Yeah.
[68:11] (4091.12s)
Amazing.
[68:11] (4091.60s)
Ideally, ideally. Yeah, installing
[68:13] (4093.20s)
dependencies. After that, it should spit
[68:16] (4096.00s)
out a link.
[68:16] (4096.80s)
This is crazy, bro. This is actually
[68:18] (4098.64s)
insane.
[68:19] (4099.76s)
Oh, man. Once again, I think it's caught
[68:21] (4101.92s)
on the server, so it never fixed the
[68:23] (4103.84s)
issue. But we do conveniently have a
[68:26] (4106.48s)
script to just solve that issue right
[68:28] (4108.64s)
here. Oh, no. No, it did. Amazing.
[68:31] (4111.92s)
Let's go.
[68:32] (4112.64s)
Good job.
[68:33] (4113.28s)
All right.
[68:33] (4113.76s)
So, now this is
[68:34] (4114.80s)
No way. Let's go. Let's go.
[68:36] (4116.88s)
We can go and resize this image.
[68:39] (4119.12s)
So, you can gradient.
[68:40] (4120.32s)
Oh my god. It just works.
[68:43] (4123.04s)
Wait, wait, wait. What happened?
[68:44] (4124.80s)
I'm resizing the image.
[68:45] (4125.92s)
Oh, I see. I see. I see. Let's go.
[68:47] (4127.28s)
Oh, okay. I can make this like I don't
[68:50] (4130.24s)
know like what was the original image
[68:52] (4132.00s)
size? But yeah, no, we have an image
[68:53] (4133.44s)
resizer website now.
[68:54] (4134.72s)
Let's go. Let's go. Okay. So, now the
[68:57] (4137.04s)
main functionality works. We just need
[68:58] (4138.80s)
to put it on our app.
[69:00] (4140.96s)
Go see if the styling worked.
[69:02] (4142.96s)
Local host.
[69:03] (4143.76s)
Oh, yeah. Yeah. Yeah. Okay. True. Let's
[69:05] (4145.76s)
try this thing.
[69:06] (4146.72s)
Accept. Right.
[69:07] (4147.52s)
Let's see. Switch the background div to
[69:09] (4149.20s)
be in line. Yeah. the only element
[69:10] (4150.80s)
layered above. Do I need to accept you
[69:12] (4152.72s)
or anything?
[69:14] (4154.56s)
Maybe. Cool.
[69:16] (4156.72s)
Ain't no way. That's our website.
[69:18] (4158.88s)
No, it's not. Oh, that's ours. Let's go.
[69:21] (4161.44s)
Yeah, it is.
[69:22] (4162.08s)
All right. All right. All right. Can you
[69:23] (4163.44s)
Can we Let's do one more styling prompt.
[69:25] (4165.20s)
We need to get rid of that weird thing
[69:26] (4166.32s)
on the left there.
[69:27] (4167.12s)
What? This thing? This?
[69:28] (4168.00s)
Yeah, that thing's nasty. Just get rid
[69:29] (4169.44s)
of it.
[69:29] (4169.92s)
The public
[69:31] (4171.60s)
plus and public button on the left of
[69:35] (4175.36s)
the text input.
[69:36] (4176.56s)
Yeah. And then make the background of
[69:39] (4179.12s)
the text input black. Just make it fully
[69:41] (4181.92s)
black.
[69:42] (4182.72s)
Make the text input
[69:46] (4186.32s)
background fully black.
[69:49] (4189.60s)
like opacity zero. I mean like what?
[69:52] (4192.40s)
Opacity.
[69:53] (4193.12s)
Go switch. Open up lovable. It's down
[69:55] (4195.04s)
below. Bro, ours looks better. Oh, they
[69:58] (4198.00s)
have the like the nice typing. That's
[69:59] (4199.12s)
okay. We don't need to edit that now.
[70:00] (4200.96s)
But like all right, come on, son. Yeah,
[70:03] (4203.28s)
this is
[70:03] (4203.60s)
and you asked Claude to connect it to
[70:06] (4206.08s)
the front end. So like in theory it
[70:07] (4207.28s)
might work, right?
[70:08] (4208.00s)
I've not asked it to the front end yet.
[70:10] (4210.72s)
So let's go and see that this script was
[70:14] (4214.24s)
generate in Daytona.ts. So now we have a
[70:18] (4218.32s)
script which is the piece of code that
[70:20] (4220.48s)
we can run that spins up an isolated
[70:23] (4223.92s)
sandbox, isolated environment or sandbox
[70:26] (4226.64s)
or bubble whatever we want to call it.
[70:29] (4229.04s)
And then inside of that bubble, cloud
[70:30] (4230.88s)
code SDK will go and create a Nex.js
[70:33] (4233.68s)
website. And then that website we can
[70:36] (4236.16s)
peek at using the link that we get from
[70:38] (4238.32s)
here. Preview URL. Great. This script is
[70:42] (4242.08s)
working great. As you can see, if we
[70:43] (4243.68s)
open the script, we actually have the
[70:45] (4245.68s)
image resizer that works. We can give it
[70:49] (4249.20s)
a graphic. It's a little ugly, but it's
[70:51] (4251.68s)
an MVP.
[70:52] (4252.40s)
We just wanted something to work.
[70:53] (4253.60s)
We have something working now. We have
[70:55] (4255.12s)
this script. Now we can go back to clot
[70:57] (4257.12s)
and we can say great job.
[71:00] (4260.56s)
This script successfully
[71:04] (4264.24s)
ran a function that generated a nextjs
[71:10] (4270.64s)
website and returned the preview URL
[71:16] (4276.00s)
after starting the dev server. I want
[71:19] (4279.68s)
you to make the button,
[71:22] (4282.64s)
make the text input,
[71:25] (4285.52s)
submit the prompt, and hook it up to our
[71:31] (4291.36s)
lovable clone. After the generation is
[71:35] (4295.60s)
complete, I want you to
[71:38] (4298.96s)
display the preview URL.
[71:42] (4302.96s)
Wait, shouldn't we specify where? Or
[71:44] (4304.64s)
actually, it doesn't matter. We can
[71:45] (4305.92s)
resize it later. We can just say like
[71:47] (4307.84s)
open the preview URL for now and then we
[71:50] (4310.00s)
Okay. And then we can further later.
[71:52] (4312.00s)
Yeah, we can definitely try to do that
[71:54] (4314.48s)
Now let's update the front end to use
[71:56] (4316.00s)
the new API to handle the preview URL.
[71:58] (4318.88s)
Great. Now let's update the page to use
[72:01] (4321.20s)
the new Daytona API to handle it. Okay,
[72:04] (4324.24s)
great. So cool. I'm super excited. This
[72:07] (4327.04s)
is honestly a pretty challenging task.
[72:09] (4329.28s)
Cloud code did stumble along the way. I
[72:11] (4331.84s)
think there's a lot of factors that went
[72:13] (4333.28s)
into it. We did manage to course correct
[72:15] (4335.28s)
it. But Daytona is super new technology.
[72:18] (4338.96s)
Test the full integration. No, stop.
[72:23] (4343.36s)
I'mma just stop it. Don't test that. I
[72:25] (4345.20s)
want to test it myself. Okay. So, this
[72:28] (4348.64s)
is the real lovable. This is our
[72:30] (4350.16s)
lovable.
[72:30] (4350.80s)
Wait, so it's ready to test?
[72:32] (4352.00s)
Yeah. Yeah. Make me a blog. Make me a
[72:34] (4354.08s)
modern blog website that supports
[72:35] (4355.92s)
markdown support.
[72:37] (4357.52s)
Oh, wow.
[72:38] (4358.64s)
Let's go. Let's go. Okay. All right. All
[72:41] (4361.12s)
right. Let's go.
[72:42] (4362.72s)
Please. It's verifying. It's generation
[72:45] (4365.36s)
script. Generation script verified.
[72:48] (4368.80s)
Create a modern website that a website
[72:51] (4371.76s)
with markdown support. So, this may take
[72:53] (4373.76s)
several minutes. Oh, running cloud code.
[72:55] (4375.76s)
So, yeah, now it's running cloud code
[72:57] (4377.36s)
generation. Waiting for a server to
[72:59] (4379.68s)
start. I think we're actually really
[73:01] (4381.20s)
close. Oh, look. Now it opened. Oh, it
[73:04] (4384.72s)
failed to do a prompt.
[73:06] (4386.00s)
All right. That's all right. That's all
[73:06] (4386.88s)
right.
[73:07] (4387.60s)
Auto prefixer. Okay. It definitely
[73:10] (4390.32s)
failed but the idea is there where we
[73:13] (4393.52s)
have a
[73:14] (4394.48s)
cuz if it's a preview I mean think about
[73:16] (4396.00s)
how many times when you use these vibe
[73:18] (4398.08s)
coding tools where you ask it to make
[73:19] (4399.44s)
something and then that is the view on
[73:20] (4400.96s)
the right side of the screen which is
[73:22] (4402.24s)
that preview error that happens all the
[73:24] (4404.16s)
That is true. You know we can ask it for
[73:26] (4406.24s)
something simpler maybe like make me
[73:29] (4409.04s)
a landing page. Just make me a landing
[73:30] (4410.96s)
page for my banana company. a landing
[73:34] (4414.16s)
page for a company
[73:38] (4418.32s)
that sells bananas.
[73:42] (4422.08s)
Okay. I would like to see the
[73:45] (4425.84s)
claw code agent trajectory. I'd like to
[73:49] (4429.84s)
see the cloud code agent trajectory.
[73:51] (4431.68s)
Currently, it just says
[73:54] (4434.96s)
this may take a few minutes and goes
[73:59] (4439.12s)
silent.
[74:00] (4440.88s)
I would like to see which tool calls
[74:05] (4445.28s)
are being used.
[74:08] (4448.40s)
And here is an image. Oops. Yeah, I'll
[74:11] (4451.04s)
just give you them all actually.
[74:14] (4454.32s)
All right.
[74:14] (4454.72s)
Yeah. Yeah. Okay. Yeah, that works.
[74:16] (4456.40s)
Go cook. So now that guy is cooking. Now
[74:20] (4460.72s)
at the same time, we are also cooking
[74:24] (4464.40s)
I see. Oh, see. Look. Oh, world's
[74:27] (4467.04s)
All right. Making progress. Let's go.
[74:28] (4468.48s)
The world's finest bananas. You know
[74:30] (4470.40s)
why? We sell the classic yellow bananas
[74:33] (4473.04s)
for $5 a pound, the platinum premium for
[74:37] (4477.04s)
$4 a pound. Why does that get cheaper?
[74:39] (4479.68s)
Okay, interesting. 100% organic, fast
[74:42] (4482.80s)
delivery, sustainably sourced. Wow. You
[74:46] (4486.48s)
know, I'd like more graphics, but that's
[74:48] (4488.64s)
fine. Honestly, this looks like not a
[74:51] (4491.28s)
not a terrible landing page.
[74:52] (4492.80s)
I mean, it's a pretty bad landing page,
[74:54] (4494.64s)
but at least it's a landing page. It's a
[74:56] (4496.48s)
pretty bad landing page, but it's pretty
[74:58] (4498.16s)
impressive that, you know, we did it.
[75:00] (4500.40s)
Okay, let's see.
[75:01] (4501.44s)
Do the image resizer one, but like make
[75:03] (4503.52s)
it like adding border around the image
[75:06] (4506.16s)
website that allows me to upload an
[75:10] (4510.32s)
image and it adds a border to
[75:12] (4512.96s)
and I can change the thickness of the
[75:14] (4514.96s)
border. I should be able to change the
[75:18] (4518.96s)
thickness of the
[75:21] (4521.28s)
and the um the rounded edges.
[75:24] (4524.88s)
Rounded edges.
[75:26] (4526.32s)
Corners. Corners.
[75:27] (4527.20s)
Rounded corners and the color. Okay.
[75:33] (4533.20s)
no way, bro. That's crazy. All right.
[75:35] (4535.76s)
It's it
[75:38] (4538.80s)
Yeah. Yeah. Yeah. So definitely like a
[75:41] (4541.12s)
little janky like super
[75:42] (4542.56s)
Yeah. Yeah. Yeah. Like what the hell?
[75:46] (4546.48s)
That is awesome. Let's go.
[75:49] (4549.28s)
Yeah. You can see exactly what the agent
[75:51] (4551.12s)
is thinking now. You know, it's Oh,
[75:52] (4552.80s)
actually, no. No. This is the prompt.
[75:54] (4554.40s)
Okay. It goes silent again. But this is
[75:56] (4556.80s)
kind of the prompt. Make me a website
[75:58] (4558.32s)
that allows me to upload an image and
[76:00] (4560.48s)
adds border to it. I should be able to
[76:02] (4562.00s)
change the prompt. I don't know if it
[76:04] (4564.00s)
managed to successfully catch like the
[76:06] (4566.80s)
messages that are being
[76:08] (4568.80s)
That's okay. Hey, that's okay. If it
[76:10] (4570.08s)
renders on the side, I'll be like super
[76:11] (4571.60s)
hyped.
[76:12] (4572.08s)
Yeah, I definitely know.
[76:13] (4573.20s)
What does it go? Wait, scroll up slowly
[76:14] (4574.96s)
on the right side. Yeah. Yeah, right
[76:16] (4576.24s)
there. What is that? Oh,
[76:17] (4577.12s)
spinning up preview. It's just centered
[76:19] (4579.52s)
in the whole thing. Yeah, we definitely
[76:21] (4581.36s)
need to tell it to like keep this max
[76:23] (4583.44s)
height.
[76:23] (4583.84s)
We can't fix that.
[76:27] (4587.36s)
It's still working.
[76:30] (4590.40s)
And then, oh, it should automatically
[76:32] (4592.48s)
render in the right side. Ideally
[76:34] (4594.40s)
the chat should take up like 30%.
[76:39] (4599.52s)
And the website preview should so please
[76:43] (4603.60s)
also fix that.
[76:46] (4606.48s)
After these fixes we can generate a cool
[76:49] (4609.68s)
website on
[76:50] (4610.56s)
cool website little app.
[76:51] (4611.92s)
Think of a little fun website.
[76:53] (4613.28s)
Fun app that will render on the screen.
[76:56] (4616.08s)
It looks pretty good and it is stored
[76:58] (4618.96s)
not in your own codebase. stored in a
[77:01] (4621.68s)
container or a isolated environment.
[77:04] (4624.48s)
Let's see if it works.
[77:05] (4625.28s)
Yeah. What would you want to generate?
[77:06] (4626.40s)
Let's generate something really cool.
[77:07] (4627.60s)
So, let's build something with our
[77:08] (4628.72s)
lovable clone that we created with cloud
[77:11] (4631.04s)
code that uses cloud code.
[77:13] (4633.52s)
Should we tell it to generate create
[77:14] (4634.96s)
lovable?
[77:15] (4635.76s)
Build.
[77:17] (4637.44s)
Let's tell it to do exactly what we did
[77:19] (4639.28s)
today. Build something with lovable.
[77:22] (4642.56s)
Built with clawed code.
[77:24] (4644.88s)
All right. Build something with lovable.
[77:26] (4646.64s)
Wait, can you put that in the subtitle?
[77:28] (4648.08s)
And we should we can move this down into
[77:30] (4650.24s)
like H3s. H3
[77:33] (4653.92s)
built with build a website.
[77:36] (4656.72s)
We can think about this.
[77:37] (4657.92s)
Flappy bird.
[77:38] (4658.72s)
A pomodoro timer.
[77:42] (4662.00s)
What about
[77:43] (4663.52s)
a link tree?
[77:44] (4664.64s)
Yeah. Link tree.
[77:45] (4665.92s)
I like it. I like it.
[77:46] (4666.72s)
Yeah. Yeah. Yeah.
[77:47] (4667.28s)
All right. All right. Let's do that.
[77:48] (4668.64s)
Okay. So,
[77:49] (4669.84s)
build me a personal link tree. personal
[77:53] (4673.84s)
link tree
[77:54] (4674.40s)
that allows me to upload my links
[77:57] (4677.84s)
with name and I can name each link
[78:00] (4680.00s)
and name each link make it sleek sleek
[78:06] (4686.64s)
make it sleek
[78:07] (4687.76s)
modern
[78:09] (4689.28s)
and beautiful
[78:12] (4692.24s)
my personal link tree that allows me to
[78:13] (4693.84s)
upload my links and name each link make
[78:16] (4696.16s)
it sleek modern beautiful
[78:17] (4697.68s)
amazing let's try it
[78:18] (4698.72s)
let's run it
[78:19] (4699.60s)
all right our lovable clone is going to
[78:21] (4701.76s)
work nice work. Good job. There it is.
[78:24] (4704.64s)
And so, can you scroll on the left side?
[78:26] (4706.32s)
Right. That's how it should work. Yeah.
[78:28] (4708.72s)
So, cool. Build me a personal link tree
[78:30] (4710.96s)
that allows me to upload my link and
[78:32] (4712.56s)
name each linking computer.
[78:34] (4714.96s)
And this is
[78:35] (4715.68s)
Wait, wait. Run it on lovable. Run the
[78:37] (4717.20s)
same copy the prompt. Run the same pro.
[78:39] (4719.52s)
Oh, you probably don't have a lovable
[78:40] (4720.72s)
account.
[78:41] (4721.12s)
I don't, but I mean, do do I do I have
[78:43] (4723.52s)
to pay? Do I not get a
[78:44] (4724.72s)
Yeah, just you get you get a free one.
[78:45] (4725.92s)
There you go. Basic.
[78:48] (4728.16s)
Great.
[78:48] (4728.88s)
Okay, so we're running it on Levelable.
[78:50] (4730.24s)
Now, go back to our other one. So, this
[78:52] (4732.48s)
is the lovable that we made. You know,
[78:56] (4736.08s)
similar
[78:57] (4737.20s)
pretty similar. I'm surprised they chose
[78:59] (4739.36s)
such a
[79:00] (4740.72s)
Gray. Yeah. Like
[79:02] (4742.64s)
maybe there's something there though,
[79:03] (4743.84s)
like they want you to like get bored by
[79:06] (4746.24s)
it and then like your site captivates
[79:09] (4749.68s)
Maybe something like that.
[79:11] (4751.68s)
Yeah. I do have to say
[79:13] (4753.52s)
ours is better. Yeah.
[79:15] (4755.28s)
No, I like a lot of what Lovable has
[79:17] (4757.68s)
Me, too. It doesn't feel very crowded
[79:19] (4759.84s)
given how many I know they have a lot of
[79:21] (4761.52s)
features though like oh okay these are
[79:23] (4763.76s)
cool these are cool quality of life
[79:25] (4765.84s)
things we failed to get our agent to
[79:28] (4768.08s)
properly speak to us that was something
[79:30] (4770.24s)
it's not too difficult but I don't feel
[79:32] (4772.88s)
like reading any more Daytona docs today
[79:36] (4776.16s)
this is cool
[79:37] (4777.36s)
let's go back to ours and wait for it to
[79:39] (4779.44s)
our project is nearly done
[79:47] (4787.52s)
Oh. Okay. So, we have these links. You
[79:51] (4791.52s)
can paste a link here.
[79:53] (4793.20s)
You can manage links.
[79:55] (4795.44s)
Yeah. So, wait. Can you paste? Can you
[79:57] (4797.12s)
add one
[79:57] (4797.76s)
like manage links?
[79:58] (4798.96s)
Oh, what does this point me to?
[80:00] (4800.32s)
Oh, it took you to the link.
[80:02] (4802.00s)
How did it know what my
[80:03] (4803.12s)
No, no, there's a manage link button on
[80:04] (4804.88s)
it. So, hit
[80:05] (4805.68s)
manage links.
[80:06] (4806.96s)
Okay. So, you can manage the link and
[80:09] (4809.44s)
No, this is pretty cool. We can edit our
[80:11] (4811.52s)
own links. So, I can go ahead and grab
[80:14] (4814.00s)
my GitHub, actually. Yeah, just grab
[80:15] (4815.60s)
anything.
[80:16] (4816.16s)
Let's grab this.
[80:17] (4817.68s)
Young Khan. So,
[80:19] (4819.12s)
this is Lovables and this is ours.
[80:21] (4821.12s)
All right. You know what?
[80:22] (4822.16s)
They look
[80:23] (4823.12s)
I mean, the gradient's like somewhat
[80:25] (4825.04s)
better. I mean, fine. You know, it's
[80:26] (4826.96s)
harder to read their text, but I add in
[80:29] (4829.36s)
one manage one of the links here.
[80:31] (4831.04s)
I mean, I'm just genuinely shocked at
[80:32] (4832.96s)
like how similar they are.
[80:34] (4834.80s)
Yeah. I mean, we've only been working on
[80:37] (4837.04s)
this for two hours. So,
[80:38] (4838.72s)
yeah, I know. I mean, crap. Is this
[80:41] (4841.36s)
Lovables? Oh, this is love voice. Yeah.
[80:43] (4843.44s)
GitHub link.
[80:45] (4845.12s)
Paste the URL.
[80:47] (4847.12s)
Oh, I mean I mean that's it, I guess.
[80:48] (4848.96s)
That's
[80:49] (4849.52s)
You know what? They're similar. They're
[80:50] (4850.72s)
similar. But the point is in two hours
[80:52] (4852.48s)
we created like a respectable clone. I
[80:55] (4855.12s)
mean go if you want to go over to ours.
[80:57] (4857.52s)
Hit add link.
[80:58] (4858.72s)
Oh yeah.
[80:59] (4859.92s)
Wait, how do you reset it so it doesn't
[81:02] (4862.48s)
Oh, yeah. Yeah. Back
[81:03] (4863.36s)
back to links.
[81:04] (4864.16s)
Yeah. Yeah. Yeah. So I mean yeah, we
[81:05] (4865.52s)
created this link tree. Uh we also
[81:07] (4867.60s)
created on lovable. It takes you to the
[81:09] (4869.44s)
link. Let's go.
[81:10] (4870.72s)
Very neat. Let's see if Lovables takes
[81:12] (4872.48s)
us to the lake. Yeah, it does. Cool.
[81:16] (4876.24s)
Amazing.
[81:17] (4877.28s)
Yeah. And yeah, that's what we created
[81:20] (4880.16s)
in about two hours using claude code. So
[81:23] (4883.68s)
in summary, within cursor, we ran cloud
[81:26] (4886.56s)
code. Like we used cloud code in cursor
[81:28] (4888.56s)
and we used claude code to build a
[81:32] (4892.24s)
lovable clone that used the cloud code
[81:34] (4894.80s)
SDK. So cloud code built cloud code
[81:37] (4897.28s)
which we wrapped and called it lovable
[81:39] (4899.20s)
clone. And then we used lovable clone to
[81:41] (4901.76s)
build an app.
[81:42] (4902.80s)
Build a link tree app.
[81:43] (4903.92s)
That's what we did.
[81:44] (4904.64s)
I didn't write a single line of code. If
[81:46] (4906.80s)
you think about it, I just vive coded
[81:48] (4908.64s)
this whole thing.
[81:49] (4909.52s)
Yeah, you did vive code. I mean, there
[81:51] (4911.12s)
was there was invest. You looked through
[81:52] (4912.72s)
code in documentation, but like
[81:55] (4915.84s)
soon basically the limitation was cloud
[81:58] (4918.08s)
code not looking through the docs well
[82:00] (4920.56s)
enough. And as soon as that gets better,
[82:02] (4922.88s)
it probably would have cut a lot of time
[82:05] (4925.28s)
out of this. I think honestly this
[82:07] (4927.28s)
project and you know I kind of did say
[82:09] (4929.20s)
this going forward that it is a little
[82:10] (4930.96s)
bit more complicated to have separate
[82:14] (4934.00s)
systems and spin up your own isolated
[82:16] (4936.88s)
environment and have code development be
[82:19] (4939.04s)
done there and then port that over to
[82:20] (4940.56s)
our website. That is definitely more
[82:22] (4942.32s)
complicated. It is like a pretty
[82:24] (4944.40s)
powerful thing that we managed to
[82:26] (4946.72s)
accomplish without me writing a single
[82:29] (4949.12s)
line of code. I think you're absolutely
[82:30] (4950.80s)
right about how once you know these
[82:33] (4953.44s)
models are going to be better at
[82:34] (4954.88s)
searching for docs online themselves,
[82:37] (4957.44s)
this could definitely be a problem that
[82:38] (4958.80s)
it's solved. Currently, I always do
[82:40] (4960.96s)
think the skill of navigating the LLMs
[82:44] (4964.16s)
to go in the right direction will be a
[82:45] (4965.84s)
persistent skill as well as finding
[82:47] (4967.92s)
projects that people would actually like
[82:50] (4970.24s)
users would actually want. If we clean
[82:52] (4972.00s)
this project up, we will actually throw
[82:53] (4973.76s)
the link on GitHub. We'll put it in the
[82:55] (4975.52s)
description down below if you want to
[82:57] (4977.04s)
like test it out yourself. And uh yeah,
[82:58] (4978.64s)
we'll see you in the next