[00:00] (0.16s)
You see a stunning website design and
[00:02] (2.08s)
think, "I want that exact look for my
[00:04] (4.16s)
project." So, you screenshot it, paste
[00:05] (5.92s)
it into cursor or chat GPT, and ask them
[00:08] (8.40s)
to recreate it. But what do you get
[00:10] (10.00s)
back? A janky mess that looks nothing
[00:11] (11.92s)
like the original. The spacing's off,
[00:13] (13.76s)
the colors are wrong, and it's missing
[00:15] (15.60s)
half the elements. I know exactly why
[00:17] (17.60s)
this happens. You're trying to make AI
[00:19] (19.52s)
guess at designs instead of giving it
[00:21] (21.36s)
the actual data it needs. Today, I'm
[00:23] (23.84s)
going to show you three amazing methods
[00:26] (26.00s)
that can clone any website. By the end
[00:28] (28.24s)
of this video, you'll be able to take
[00:29] (29.92s)
any design you love and have it running
[00:31] (31.84s)
as your own project in minutes, not
[00:33] (33.84s)
hours. So, jumping right in, the first
[00:36] (36.48s)
method that I'm about to show you is
[00:38] (38.32s)
actually something new that I just
[00:40] (40.00s)
found. It's a really unique method of
[00:42] (42.00s)
just taking designs that you like from
[00:44] (44.00s)
already made websites or even web apps
[00:46] (46.24s)
and then recreating them so you can go
[00:48] (48.16s)
ahead and implement them on your own. I
[00:50] (50.08s)
found this from John over at egghhead.io
[00:52] (52.64s)
and he's given a full preview of the
[00:54] (54.48s)
method here as well. So let's say we
[00:56] (56.40s)
have a site here, Wall Haven, which is a
[00:58] (58.56s)
wallpaper site and it has this general
[01:00] (60.80s)
structure, right? Now, what if I just
[01:02] (62.56s)
wanted to copy the structure and then
[01:04] (64.40s)
implement everything or even use my own
[01:06] (66.56s)
wallpapers on my own site? Well, first
[01:08] (68.56s)
we need to capture the site. The method
[01:10] (70.40s)
that John actually showed was that you
[01:12] (72.32s)
could just go ahead and take a
[01:13] (73.60s)
screenshot of the whole website using
[01:15] (75.44s)
the inspect tab. Open it up, then press
[01:17] (77.68s)
commandshiftp or on Windows control
[01:20] (80.08s)
shiftp. This opens up the command
[01:22] (82.00s)
runner. in there you type screenshot and
[01:24] (84.24s)
then move to capture full-size
[01:25] (85.84s)
screenshot. This will actually capture a
[01:28] (88.08s)
screenshot of the whole site and save it
[01:30] (90.16s)
to your downloads. So that's another
[01:31] (91.92s)
trick. If you don't want to take
[01:33] (93.44s)
multiple screenshots, this is how you
[01:35] (95.44s)
can capture the whole site at once.
[01:37] (97.28s)
After you capture the screenshot, you
[01:38] (98.96s)
head over to Gemini and with the canvas
[01:41] (101.04s)
feature turned on, you tell it to
[01:42] (102.72s)
analyze the image. You can use a prompt
[01:44] (104.72s)
like this which essentially tells it to
[01:46] (106.72s)
recreate the design exactly as shown in
[01:49] (109.20s)
React and it will clone the website
[01:51] (111.20s)
design as you see right here. Even the
[01:53] (113.20s)
discussions you see over there have been
[01:55] (115.04s)
cloned and the wall haven stats have
[01:56] (116.96s)
also been cloned right here. The text as
[01:59] (119.04s)
well, it's just taken everything from
[02:00] (120.64s)
it. In this example, it didn't take the
[02:02] (122.56s)
images, but when I show you the
[02:04] (124.08s)
comparison with clawed artifacts, you'll
[02:06] (126.08s)
see that Gemini did take the image of
[02:08] (128.08s)
the interface I gave it. So, that's a
[02:09] (129.92s)
plus point. Once it's done generating,
[02:11] (131.92s)
you'll see the result here. After that,
[02:13] (133.84s)
you head into cursor and ask it to make
[02:15] (135.92s)
a next.js app. You're also going to ask
[02:18] (138.24s)
it to give you the file structure of the
[02:20] (140.16s)
app it just created. It'll give you that
[02:22] (142.16s)
file structure. And then you take that
[02:23] (143.92s)
structure and paste it into Gemini. Then
[02:26] (146.24s)
you paste this prompt, which I'll leave
[02:28] (148.00s)
in the description as well. This prompt
[02:30] (150.00s)
instructs Gemini to transfer the code
[02:32] (152.08s)
into a Nex.js app using markers, which
[02:34] (154.64s)
means splitting up the code, then
[02:36] (156.32s)
generating a terminal script that reads
[02:38] (158.32s)
these markers and inserts the code into
[02:40] (160.40s)
your app. So you don't need cursor to
[02:42] (162.32s)
break it down. It all happens here in
[02:44] (164.08s)
Gemini. Okay. So this is what I gave it.
[02:46] (166.16s)
It gave me the bash script. If I open it
[02:48] (168.24s)
up, you can see it here. And it also
[02:50] (170.00s)
gave me instructions on how to use it.
[02:51] (171.84s)
The original code was saved as
[02:53] (173.52s)
generated.tsx
[02:55] (175.20s)
just like it told me to. Then I copied
[02:57] (177.36s)
the script and saved it as
[02:58] (178.72s)
integrated.sh.
[03:00] (180.32s)
You can see that right here. After that,
[03:02] (182.08s)
I ran two commands. One to make it
[03:04] (184.08s)
executable and the other to execute it.
[03:06] (186.24s)
It integrated the entire app into my
[03:08] (188.40s)
source folder while automatically
[03:10] (190.08s)
splitting it into components. After
[03:12] (192.00s)
that, I ran the server and as always,
[03:14] (194.32s)
it's not going to be perfect. There was
[03:16] (196.08s)
one module error that I quickly solved,
[03:18] (198.16s)
then installed some dependencies, and
[03:20] (200.08s)
once those were done, the app was up and
[03:21] (201.92s)
running. It's the exact interface from
[03:23] (203.84s)
Wall Haven, and I can go ahead and
[03:25] (205.68s)
implement my backend on this app if I
[03:27] (207.60s)
want to. I found this approach really
[03:29] (209.36s)
cool. Instead of just giving cursor
[03:31] (211.28s)
screenshots or even getting it generated
[03:33] (213.52s)
from Gemini or Claude and dumping the
[03:35] (215.68s)
whole code file into cursor, I could
[03:37] (217.60s)
actually use the integrate.sh script
[03:40] (220.16s)
that automatically chops the code into
[03:42] (222.24s)
pieces and integrates it. Obviously,
[03:44] (224.08s)
there were some imports across files
[03:45] (225.84s)
that needed fixing, but cursor
[03:47] (227.68s)
automatically handled that. So, it's
[03:49] (229.44s)
much better because Gemini maintains the
[03:51] (231.52s)
context and can divide everything up
[03:53] (233.44s)
properly rather than just dumping the
[03:55] (235.36s)
code into cursor and hoping for the
[03:57] (237.12s)
best. Now, if you're wondering whether
[03:58] (238.88s)
we really need Gemini for this, let me
[04:00] (240.88s)
show you a quick comparison between
[04:02] (242.48s)
Gemini and Claude Artifacts. So, this
[04:05] (245.04s)
was the image I gave to Gemini. It's the
[04:07] (247.12s)
wallpaper page for Wall Haven. Like,
[04:09] (249.12s)
when you open up a wallpaper, this is
[04:11] (251.04s)
what you get. I gave it the exact
[04:12] (252.72s)
prompt, and this is what it came up
[04:14] (254.40s)
with. Now, the design is really, really
[04:16] (256.56s)
similar. There are some minor color
[04:18] (258.48s)
differences, but the interface is super
[04:20] (260.64s)
clean. It even grabbed the image and
[04:22] (262.56s)
placed it correctly, which is what
[04:24] (264.24s)
impressed me the most. And if I go over
[04:26] (266.00s)
to Claude, you can see I gave it the
[04:27] (267.76s)
same image and the same prompt, but what
[04:29] (269.68s)
happened was it came up with this, which
[04:31] (271.76s)
has a lot of stuff missing. In my
[04:33] (273.52s)
opinion, the Gemini version is much,
[04:35] (275.44s)
much better. Oh, and if you're enjoying
[04:37] (277.68s)
the content, please hit that subscribe
[04:39] (279.68s)
button. We've also launched channel
[04:41] (281.36s)
memberships. 93 people have already
[04:43] (283.68s)
joined our first tier. Members get
[04:45] (285.60s)
priority replies to comments, so if you
[04:47] (287.84s)
need feedback or have questions, that's
[04:49] (289.84s)
the best way to reach us. We're
[04:51] (291.36s)
considering adding more tiers based on
[04:53] (293.20s)
the incredible support so far. Now, the
[04:56] (296.00s)
first method works great when you need
[04:57] (297.84s)
to clone existing websites and implement
[05:00] (300.32s)
your own designs. But what if you're
[05:02] (302.08s)
given a Figma file like this one here
[05:04] (304.32s)
and you want to convert those designs
[05:06] (306.24s)
into code exactly as they appear? Well,
[05:08] (308.96s)
that's where the second method comes in.
[05:10] (310.80s)
The second method is using the Figma
[05:12] (312.72s)
MCP. Now, you might think that it's been
[05:14] (314.80s)
around for some time, but the author has
[05:16] (316.88s)
upgraded it and it was already pretty
[05:18] (318.72s)
amazing. But there is one single feature
[05:21] (321.04s)
that makes it so much more powerful.
[05:22] (322.80s)
Now, it's essentially running on my
[05:24] (324.64s)
system as an SSE server that I've
[05:26] (326.96s)
connected directly in cursor as you can
[05:28] (328.88s)
see it right here. I've also made a
[05:30] (330.56s)
detailed video about this MCP server,
[05:32] (332.88s)
which I'll link in the description
[05:34] (334.24s)
below. That video contains all the
[05:36] (336.24s)
installation instructions you'll need.
[05:38] (338.08s)
So, definitely check it out if you want
[05:39] (339.76s)
to get this up and running. You'll also
[05:41] (341.60s)
find all the relevant links there. But
[05:43] (343.44s)
let me show you what this tool can do.
[05:45] (345.28s)
So here's a trip app design that I found
[05:47] (347.44s)
online and I wanted to implement it.
[05:49] (349.60s)
After connecting the Figma MCP, I simply
[05:52] (352.16s)
told Cursor that I'd like to create a
[05:54] (354.08s)
mobile prototype using the tool. Then I
[05:56] (356.64s)
provided links to all the pages and it
[05:58] (358.88s)
automatically started calling the Figma
[06:00] (360.96s)
MCP to fetch data from the entire file
[06:03] (363.68s)
and then proceeded to get data from each
[06:05] (365.68s)
page one by one. Now, let me show you
[06:07] (367.60s)
the feature I'm most excited about, and
[06:09] (369.60s)
it's one of the tools of the MCP server.
[06:11] (371.92s)
Now, this MCP server only has two tools.
[06:14] (374.56s)
Get Figma data and download Figma
[06:16] (376.80s)
images. But this second one is so
[06:18] (378.72s)
powerful. All the images you see in the
[06:20] (380.88s)
design, like this avatar image, are
[06:22] (382.88s)
automatically downloaded and placed into
[06:24] (384.96s)
your project directory. They're then
[06:26] (386.64s)
seamlessly integrated into the app. This
[06:28] (388.88s)
is a gamecher because previously when
[06:31] (391.20s)
you pasted a screenshot, cursor had to
[06:33] (393.44s)
guess at recreating those images which
[06:35] (395.68s)
often led to poor results. It simply
[06:38] (398.08s)
couldn't recreate complex images
[06:40] (400.00s)
accurately. But now with the download
[06:42] (402.32s)
Figma images tool, it's become
[06:44] (404.40s)
incredibly more reliable. You can
[06:46] (406.32s)
actually see the folder structure over
[06:48] (408.00s)
there. Avatars, frames, icons, they've
[06:51] (411.28s)
all been downloaded and properly
[06:53] (413.04s)
organized in the project. And after
[06:54] (414.88s)
downloading all the images, since it had
[06:57] (417.04s)
already read the file structure, it went
[06:59] (419.04s)
ahead and implemented everything. So
[07:01] (421.20s)
let's take a look at the results. This
[07:02] (422.96s)
is what it managed to create. And
[07:04] (424.64s)
honestly, it's quite impressive. If we
[07:06] (426.72s)
open it up, we can see the app running.
[07:08] (428.72s)
There's a slight formatting issue
[07:10] (430.32s)
because of the device I selected. But
[07:12] (432.32s)
you can see that everything has been
[07:13] (433.84s)
implemented, including the avatars and
[07:15] (435.92s)
all the images exactly as they appear in
[07:18] (438.08s)
the Figma design. I should mention one
[07:20] (440.16s)
limitation. It doesn't automatically
[07:22] (442.24s)
implement navigation between screens.
[07:24] (444.56s)
For example, I had to manually instruct
[07:26] (446.56s)
it to make a card clickable to open a
[07:28] (448.64s)
menu. It didn't know to do that on its
[07:30] (450.56s)
own. However, when it comes to the
[07:32] (452.32s)
actual page designs, it really nails the
[07:34] (454.64s)
visual implementation. You can take any
[07:36] (456.72s)
Figma template you want and simply
[07:38] (458.56s)
provide the links. The tool handles the
[07:40] (460.56s)
rest. Again, if you want to understand
[07:42] (462.40s)
the complete process, especially the
[07:44] (464.48s)
installation steps, please check out the
[07:46] (466.56s)
video I mentioned. But the workflow
[07:48] (468.32s)
itself is quite straightforward. To
[07:50] (470.24s)
clone a design, you simply click on a
[07:52] (472.24s)
frame in Figma, then select copy link to
[07:54] (474.80s)
selection. Once you have that link, you
[07:56] (476.88s)
just provide it to cursor, and it knows
[07:58] (478.88s)
exactly what to do with it. What's also
[08:00] (480.80s)
great is that you can work at different
[08:02] (482.56s)
levels. You can select an entire page or
[08:05] (485.12s)
just specific components. For instance,
[08:07] (487.36s)
if I only want to clone this button, I
[08:09] (489.44s)
can select it, copy the link to that
[08:11] (491.28s)
selection, give it to cursor, and it'll
[08:13] (493.36s)
recreate just that element exactly as
[08:15] (495.84s)
designed. So, that's how the Figma MCP
[08:18] (498.08s)
works. It's become an essential tool for
[08:20] (500.08s)
anyone who needs to convert Figma
[08:22] (502.00s)
designs into actual code efficiently.
[08:24] (504.64s)
Now, before we move on to the third
[08:26] (506.24s)
method, I want to share another tip that
[08:28] (508.16s)
might help you out. You know how GitHub
[08:29] (509.92s)
is full of open-source projects with
[08:31] (511.92s)
interesting features? Let's say you find
[08:33] (513.84s)
a note-taking app. Nothing super unique,
[08:36] (516.08s)
but it has elements you'd like to
[08:37] (517.68s)
incorporate into your own project. While
[08:39] (519.68s)
you could clone and modify the entire
[08:41] (521.52s)
repository, there's actually a smarter
[08:43] (523.52s)
approach for building an MVP or drawing
[08:46] (526.00s)
inspiration from existing projects.
[08:47] (527.68s)
Here's the trick. In your browser's
[08:49] (529.36s)
address bar, simply type git2doc, which
[08:52] (532.08s)
takes you to the git 2d do website. This
[08:54] (534.40s)
tool transforms any GitHub repository
[08:56] (536.96s)
into documentation that cursor can
[08:59] (539.04s)
understand and reference. The process is
[09:00] (540.96s)
straightforward. First, copy the
[09:02] (542.64s)
repository link from the git to doc
[09:04] (544.64s)
site. Then go back to cursor and tell it
[09:07] (547.12s)
something like, I want to build an MVP
[09:09] (549.28s)
based on this app. You may use the docs
[09:11] (551.36s)
for reference. When you add a new doc,
[09:13] (553.20s)
paste the link in the input field. You
[09:15] (555.12s)
can also name the documentation for easy
[09:17] (557.20s)
reference later. Once added, cursor
[09:19] (559.36s)
begins indexing the repository's full
[09:21] (561.52s)
documentation. After indexing completes,
[09:23] (563.92s)
you have access to all the architectural
[09:26] (566.00s)
decisions, code patterns, and features
[09:28] (568.00s)
of that repository right inside cursor.
[09:30] (570.64s)
This means you can draw inspiration from
[09:32] (572.56s)
proven implementations, understand how
[09:34] (574.72s)
certain features work, or use it as a
[09:36] (576.80s)
foundation for your own unique spin on
[09:38] (578.72s)
the concept. So, the second method was
[09:41] (581.20s)
perfect when you already had fully
[09:42] (582.96s)
designed Figma files. But what if you
[09:44] (584.96s)
simply want to clone an existing
[09:46] (586.80s)
website? For example, let's take the
[09:48] (588.64s)
Obsidian website. I think it has a
[09:50] (590.72s)
really nice design. Let's say I'm
[09:52] (592.56s)
building another note-taking app and
[09:54] (594.40s)
want to use the same layout for my
[09:56] (596.16s)
landing page. This method addresses that
[09:58] (598.24s)
exact use case and it also uses another
[10:00] (600.64s)
MCP tool. The third method involves
[10:03] (603.04s)
using the Firecrawl MCP with its eight
[10:05] (605.76s)
different tools. Firecrawl lets you
[10:07] (607.52s)
provide a website link and clone it.
[10:09] (609.52s)
Here's how it works. I told cursor that
[10:11] (611.52s)
I wanted to clone the obsidian landing
[10:13] (613.36s)
page using the firecrawl mcp and then
[10:16] (616.00s)
provided the website link. It
[10:17] (617.60s)
immediately called the firecrawl scraper
[10:19] (619.68s)
tool which scrapes the entire website.
[10:21] (621.84s)
The tool pulls all the data from the
[10:23] (623.68s)
site including all the metadata behind
[10:25] (625.68s)
it. If you were to open the inspect
[10:27] (627.52s)
element and look at the div classes and
[10:29] (629.44s)
structure, it captures all of that
[10:31] (631.52s)
information. Using this data, it was
[10:33] (633.60s)
able to map out the complete structure,
[10:35] (635.76s)
extract all the text, and even grab the
[10:38] (638.00s)
images since they're embedded in the
[10:39] (639.84s)
site. Through those image links, it can
[10:41] (641.84s)
fetch and download the assets as well.
[10:44] (644.08s)
And here's what it managed to create,
[10:45] (645.84s)
which I'd say is a remarkably accurate
[10:48] (648.00s)
clone. The similarity is impressive.
[10:50] (650.24s)
There are a few limitations, though.
[10:51] (651.92s)
Some animations aren't fully replicated,
[10:54] (654.32s)
and the graph here isn't interactive
[10:56] (656.24s)
like the original. So, while there are
[10:58] (658.08s)
elements we'd need to implement
[10:59] (659.76s)
manually, the core structure is spot-on.
[11:02] (662.56s)
It even captured all the images. Though,
[11:04] (664.72s)
I should mention that copying images
[11:06] (666.64s)
from someone else's website isn't
[11:08] (668.64s)
typically useful when you're building
[11:10] (670.32s)
your own product, unless you're creating
[11:12] (672.24s)
an exact replica for testing or learning
[11:14] (674.72s)
purposes. You can see the results here.
[11:16] (676.88s)
It's cloned everything beautifully. Even
[11:19] (679.04s)
the icons are perfect, and the overall
[11:21] (681.36s)
layout matches the original precisely.
[11:23] (683.44s)
Now, I should point out that the
[11:24] (684.80s)
animations are a bit janky. When I
[11:26] (686.64s)
interact with certain elements, they go
[11:28] (688.56s)
out of frame. That's partly because I
[11:30] (690.32s)
asked Cursor to implement this in plain
[11:32] (692.48s)
HTML for simplicity. If we had used
[11:34] (694.80s)
Nex.js instead, we'd have proper
[11:36] (696.72s)
animations and better optimization
[11:38] (698.56s)
overall. Currently, there's also some
[11:40] (700.48s)
slight jittering when scrolling. Nothing
[11:42] (702.48s)
major, but noticeable. This would have
[11:44] (704.40s)
been resolved with a proper framework
[11:46] (706.24s)
implementation. As for installation,
[11:48] (708.24s)
we've created a separate video covering
[11:50] (710.16s)
the Firecrol MCP setup, which I'll link
[11:52] (712.64s)
in the description. If you're planning
[11:54] (714.24s)
to install it, that video walks through
[11:56] (716.32s)
all the necessary steps. One thing to
[11:58] (718.32s)
note, Firecrawl is a paid service, but
[12:00] (720.88s)
they offer generous free credits to
[12:02] (722.88s)
start. You can scrape up to 500 pages
[12:05] (725.36s)
before needing to upgrade to their $16
[12:07] (727.68s)
monthly plan. For testing purposes or
[12:10] (730.00s)
occasional use, the free tier is
[12:11] (731.84s)
actually quite sufficient. For more
[12:13] (733.60s)
detailed information about this
[12:15] (735.12s)
particular MCP and its capabilities,
[12:17] (737.60s)
definitely check out the dedicated
[12:19] (739.28s)
video. It's a comprehensive guide to
[12:21] (741.28s)
everything Firecrawl can do. That brings
[12:23] (743.68s)
us to the end of this video. If you'd
[12:25] (745.52s)
like to support the channel and help us
[12:27] (747.36s)
keep making videos like this, you can do
[12:29] (749.44s)
so by using the super thanks button
[12:31] (751.36s)
below. As always, thank you for watching
[12:33] (753.44s)
and I'll see you in the next one.