[00:00] (0.16s)
Are you struggling to turn beautiful
[00:01] (1.92s)
website designs into actual working code
[00:04] (4.32s)
with cursor? You're not alone. In my
[00:06] (6.40s)
previous video about building beautiful
[00:08] (8.24s)
websites with cursor, you guys
[00:09] (9.76s)
absolutely loved it and it got an
[00:11] (11.60s)
amazing response. Here's the thing
[00:13] (13.12s)
though. In that video, I actually showed
[00:15] (15.04s)
you how you can get a beautiful UI, but
[00:17] (17.12s)
I didn't show you how you could properly
[00:18] (18.72s)
implement it. You can't just go ahead
[00:20] (20.32s)
and tell cursor this is the design file
[00:22] (22.56s)
or use this reference, ask it to clone
[00:24] (24.80s)
it, and then expect it to work. it'll
[00:26] (26.80s)
actually start to build stuff on its own
[00:28] (28.64s)
which usually ends up as hallucination
[00:30] (30.56s)
or AI slop that no one really likes. So
[00:33] (33.12s)
in today's video I'm going to tell you
[00:35] (35.04s)
three ways you can actually build the
[00:36] (36.96s)
beautiful UI that you created. Whether
[00:38] (38.96s)
you're coming from my previous video or
[00:40] (40.88s)
you're completely new here by the end of
[00:42] (42.88s)
this you'll know exactly how to get
[00:44] (44.72s)
cursor to build the websites you
[00:46] (46.48s)
actually want. So in the previous video
[00:49] (49.04s)
I actually shared a prompt that allowed
[00:51] (51.04s)
you to convert any design image you gave
[00:53] (53.28s)
to an AI model like claude or chatgpt
[00:55] (55.92s)
into JSON format. Then using that JSON
[00:58] (58.64s)
format you could accurately create a
[01:00] (60.56s)
design template and reuse it anywhere.
[01:02] (62.72s)
Well, I've also improved that prompt a
[01:04] (64.56s)
little bit and made some changes so that
[01:06] (66.24s)
the JSON output is even better. You'll
[01:08] (68.32s)
find this updated prompt in the
[01:09] (69.92s)
description as well. But to start
[01:11] (71.60s)
building projects you can actually
[01:13] (73.04s)
scale, you need this first method. So
[01:15] (75.60s)
let's go ahead and get started. This is
[01:17] (77.44s)
actually a pretty powerful prompt
[01:19] (79.04s)
template that we've developed. Instead
[01:20] (80.64s)
of cursor guessing what you want, this
[01:22] (82.56s)
injects the full functionality and
[01:24] (84.56s)
structure of your front-end app right
[01:26] (86.64s)
into the AI's context from the start.
[01:29] (89.04s)
There are specific prompt fields to fill
[01:30] (90.96s)
out. First, the required pages that need
[01:33] (93.28s)
to be made, then user roles and
[01:35] (95.20s)
permissions for authentication. If you
[01:37] (97.04s)
want authentication in your app, which
[01:38] (98.96s)
is actually very important for real
[01:40] (100.72s)
projects, then you absolutely need to
[01:42] (102.64s)
include this. Shared components are also
[01:45] (105.04s)
mentioned like navigation bar, header
[01:47] (107.28s)
and breadcrumbs. Then we have modals and
[01:49] (109.60s)
pop-ups which if you list them at the
[01:51] (111.52s)
beginning really helps because the AI
[01:53] (113.68s)
will develop the front-end app
[01:55] (115.20s)
accordingly and everything gets
[01:56] (116.88s)
integrated properly. There are also
[01:58] (118.72s)
technical requirements you can include
[02:00] (120.56s)
which make it way easier to connect the
[02:02] (122.48s)
app to a back end later on and you can
[02:04] (124.40s)
specify whichever framework you want to
[02:06] (126.40s)
use for your app. The best part is you
[02:08] (128.32s)
don't even have to fill this out
[02:09] (129.60s)
yourself if you don't want to. For
[02:11] (131.12s)
example, you can see that I gave the
[02:12] (132.88s)
prompt to Claude and it just went ahead
[02:14] (134.72s)
and filled everything out for me. And
[02:16] (136.32s)
the reason I gave this prompt to Claude
[02:18] (138.24s)
is what I want to demo. So, I wanted to
[02:20] (140.40s)
make a weather app with the style and
[02:22] (142.40s)
design of the cursor landing page. You
[02:24] (144.48s)
can see it has this gradient infused
[02:26] (146.72s)
layout where the same gradient is used
[02:28] (148.72s)
throughout all the components. What I
[02:30] (150.72s)
did was take around six or seven
[02:32] (152.40s)
screenshots, put them into Claude, and
[02:34] (154.40s)
gave it the prompt that produces the
[02:36] (156.00s)
JSON output you saw earlier. Claude then
[02:38] (158.40s)
generated the JSON for creating a web
[02:40] (160.56s)
app with the cursor UI design profile.
[02:43] (163.12s)
Since I wanted to build the full front
[02:44] (164.96s)
end of the weather app, I told it I'd be
[02:47] (167.20s)
using Nex.js with Tailwind. So, I
[02:49] (169.36s)
specified the framework. I also asked it
[02:51] (171.60s)
to fill out the front-end template we
[02:53] (173.44s)
looked at earlier, and it did exactly
[02:55] (175.20s)
that. It created the required pages, the
[02:57] (177.84s)
user roles and permissions, the modles
[03:00] (180.00s)
and pop-ups, and it even added technical
[03:02] (182.24s)
requirements. Because we gave the full
[03:04] (184.08s)
prompt to Claude, it could pre-plan all
[03:06] (186.16s)
the components that need to be made.
[03:08] (188.00s)
That means cursor or any AI agent you're
[03:10] (190.48s)
using doesn't have to guess or figure
[03:12] (192.40s)
out what components to create and you
[03:14] (194.32s)
don't have to face the frustration and
[03:16] (196.16s)
you can always go back and edit things
[03:17] (197.92s)
later. Nothing here is set in stone. All
[03:20] (200.64s)
right, let me show you the first method
[03:22] (202.56s)
in action. You can see that I'm in
[03:24] (204.32s)
cursor right now and this is the
[03:26] (206.00s)
design.json file that I have open here.
[03:28] (208.80s)
This is the JSON file we got from
[03:30] (210.48s)
Claude. After that, I asked cursor to
[03:32] (212.64s)
install a nextjs app. I gave it the full
[03:35] (215.36s)
prompt that claude filled out using the
[03:37] (217.36s)
template. I told cursor build the
[03:39] (219.36s)
front-end app in this nextjs app and for
[03:41] (221.92s)
the design strictly follow the
[03:43] (223.76s)
design.json that I provided. It went
[03:46] (226.40s)
ahead and started creating the app. Now,
[03:48] (228.40s)
it did take some time and there were
[03:50] (230.40s)
some version conflicts that cursor
[03:52] (232.24s)
couldn't handle. So, I brought in clawed
[03:54] (234.24s)
code to help fix those. And this is the
[03:56] (236.48s)
website it generated. You can see that
[03:58] (238.48s)
it accurately follows the gradient
[04:00] (240.32s)
design we saw on the cursor landing
[04:02] (242.32s)
page. In the prompt, I specifically
[04:04] (244.32s)
asked it to focus on how the gradients
[04:06] (246.48s)
were created, which is why it looks
[04:08] (248.24s)
exactly like this. If you look at the
[04:09] (249.84s)
cards below, you'll notice they also
[04:11] (251.68s)
mirror how the cards were styled on the
[04:13] (253.68s)
cursor landing page. The rest of that
[04:15] (255.36s)
page was mostly clean and dark, so there
[04:17] (257.60s)
wasn't much else to pick up from the
[04:19] (259.12s)
JSON. But as you can see, it nailed the
[04:21] (261.36s)
gradient design perfectly. Now, I want
[04:23] (263.68s)
to be transparent here. This design
[04:25] (265.60s)
wasn't perfect on the first try. Cursor
[04:27] (267.76s)
made some mistakes that I had to
[04:29] (269.20s)
correct, but it provided an excellent
[04:31] (271.04s)
foundation to work from. Later on, I'll
[04:33] (273.44s)
also show how you can accurately do that
[04:35] (275.52s)
as well. Oh, and if you're enjoying the
[04:37] (277.92s)
content we're making, I'd really
[04:39] (279.52s)
appreciate it if you hit that subscribe
[04:41] (281.36s)
button. We're also testing out channel
[04:43] (283.20s)
memberships. Launched the first tier as
[04:45] (285.12s)
a test, and 79 people have joined so
[04:47] (287.68s)
far. The support's been incredible, so
[04:49] (289.68s)
we're thinking about launching
[04:50] (290.96s)
additional tiers. Right now, members get
[04:53] (293.36s)
priority replies to your comments.
[04:55] (295.28s)
Perfect if you need feedback or have
[04:57] (297.12s)
questions. Now, the second method is
[04:59] (299.20s)
perfect for when you want to copy the
[05:00] (300.96s)
structure of an existing site and then
[05:02] (302.96s)
apply your own design on top of it. This
[05:05] (305.04s)
is incredibly useful because instead of
[05:06] (306.88s)
building everything from scratch, you
[05:08] (308.64s)
can leverage proven layouts and just
[05:10] (310.48s)
make them your own. For that, you can
[05:12] (312.24s)
use this amazing tool called Browser
[05:14] (314.40s)
MCP. It's completely free and I'll link
[05:16] (316.72s)
it in the description so you can grab it
[05:18] (318.64s)
right after this video. Browser MCP has
[05:21] (321.12s)
two parts you need to set up, but don't
[05:23] (323.04s)
worry, it's straightforward. First,
[05:24] (324.88s)
install the browser extension from the
[05:26] (326.72s)
Chrome Web Store. This extension is what
[05:28] (328.80s)
allows the tool to actually interact
[05:30] (330.56s)
with web pages. Then, for any page you
[05:33] (333.28s)
want to clone, you just connect browser
[05:35] (335.28s)
MCP to that specific tab like this.
[05:37] (337.60s)
Second, you need to set up the MCP
[05:39] (339.76s)
server inside cursor itself. Go to their
[05:42] (342.24s)
documentation and in the install
[05:44] (344.00s)
section, find the setup for your IDE and
[05:46] (346.48s)
paste the config into your MCP.json JSON
[05:49] (349.28s)
file. Pretty straightforward and their
[05:51] (351.04s)
documentation walks you through
[05:52] (352.72s)
everything. Once that's done, I
[05:54] (354.48s)
recommend using the prompt you see here
[05:56] (356.32s)
and filling it with the link of the
[05:57] (357.92s)
website that you want to clone. Now, I
[06:00] (360.00s)
choose the monkey type website as an
[06:01] (361.92s)
example, but honestly, its structure is
[06:04] (364.16s)
pretty simple. So, there wasn't much to
[06:06] (366.00s)
copy. But even with this basic site, it
[06:08] (368.48s)
still did a solid job, which shows you
[06:10] (370.32s)
how powerful this method really is.
[06:12] (372.32s)
Here's why it works so well. This MCP
[06:14] (374.72s)
actually spins up a real browser and
[06:16] (376.88s)
navigates like a real person would. It's
[06:18] (378.96s)
not just scraping HTML. It's actually
[06:21] (381.20s)
experiencing the site. You can see it
[06:23] (383.20s)
has a browser screenshot tool that takes
[06:25] (385.28s)
screenshots, helping it understand not
[06:27] (387.28s)
just the code, but the actual visual
[06:29] (389.04s)
structure and layout perfectly. In the
[06:30] (390.96s)
prompt, I tell it to explore the website
[06:33] (393.04s)
thoroughly and break down the
[06:34] (394.56s)
architecture, navigation patterns, and
[06:36] (396.88s)
styling approaches. If you want to use
[06:38] (398.72s)
your own design with the JSON method
[06:40] (400.72s)
from earlier, just remove that part from
[06:42] (402.80s)
the prompt and it'll focus purely on
[06:44] (404.88s)
structure. After it gathers all the data
[06:47] (407.04s)
from its exploration, I asked it to
[06:49] (409.20s)
build the clone in next.js. And here's
[06:51] (411.84s)
the result. It created this fully
[06:53] (413.84s)
functional site. I can type in it. It
[06:55] (415.92s)
catches errors properly. Different modes
[06:58] (418.16s)
and pages work seamlessly because it
[07:00] (420.48s)
actually navigated and understood how
[07:02] (422.48s)
the original site functions, not just
[07:04] (424.56s)
how it looks. Now, this method gives you
[07:06] (426.48s)
the perfect foundation and structure.
[07:08] (428.40s)
But what about when you need to apply
[07:10] (430.16s)
your own custom design on top or make
[07:12] (432.48s)
precise tweaks to specific elements?
[07:14] (434.80s)
That's where method 3 comes in and it's
[07:16] (436.72s)
a game changer. So, the third method
[07:19] (439.36s)
focuses on something that's absolutely
[07:21] (441.36s)
crucial, making precise UI tweaks
[07:23] (443.84s)
without breaking everything else. What
[07:25] (445.68s)
I'm going to show you is how to get this
[07:27] (447.36s)
interactive bar that lets you select
[07:29] (449.36s)
individual or even multiple elements and
[07:31] (451.68s)
send them back to Cursor with exact
[07:33] (453.52s)
details about their location and what
[07:35] (455.36s)
those elements are. This eliminates the
[07:37] (457.36s)
guesswork and ensures Cursor knows
[07:39] (459.36s)
precisely what to edit without messing
[07:41] (461.44s)
up the rest of your site. And trust me,
[07:43] (463.44s)
this precision is everything when you're
[07:45] (465.20s)
working on real projects where one wrong
[07:47] (467.28s)
change can break your entire layout. The
[07:49] (469.44s)
setup is actually really simple, but the
[07:51] (471.60s)
results are powerful. Just go into
[07:53] (473.44s)
cursor, open the extensions tab and
[07:55] (475.68s)
search for stage wise, install it, then
[07:57] (477.92s)
open your command pallet with command
[07:59] (479.76s)
plus shift + p, type stage wise, and
[08:02] (482.32s)
it'll bring up all the related commands
[08:04] (484.24s)
you need. Here's something important to
[08:06] (486.00s)
keep in mind. You have to set up stage
[08:08] (488.00s)
wise in each project individually. It
[08:10] (490.32s)
actually modifies your code and sets
[08:12] (492.48s)
everything up automatically for that
[08:14] (494.24s)
specific project. Just select the
[08:16] (496.00s)
appropriate option and it will enter a
[08:17] (497.92s)
prompt into your cursor agent telling it
[08:20] (500.00s)
to initialize the stage wise bar in your
[08:22] (502.24s)
project. I've already done that setup
[08:24] (504.00s)
here and as you can see it ran the full
[08:26] (506.40s)
prompt and set everything up perfectly.
[08:28] (508.64s)
Now I have this powerful tool where I
[08:30] (510.64s)
can select each element individually and
[08:33] (513.12s)
send it back to cursor with exactly how
[08:35] (515.36s)
I want it edited. No more vague
[08:37] (517.36s)
instructions that could be
[08:38] (518.48s)
misinterpreted. For example, look at
[08:40] (520.40s)
this restart button right now. It's just
[08:42] (522.72s)
plain text and only becomes a button
[08:44] (524.80s)
when I hover over it. That's a small UI
[08:46] (526.96s)
tweak, but this is exactly where stage
[08:49] (529.04s)
wise becomes super handy. If I just went
[08:51] (531.28s)
back and told cursor to update the
[08:53] (533.20s)
restart button, there's a chance it
[08:54] (534.80s)
might fix it correctly, but there's also
[08:56] (536.56s)
a chance it might break or alter
[08:58] (538.32s)
something else entirely, which I
[08:59] (539.92s)
obviously don't want. Instead, I can be
[09:01] (541.92s)
surgical about it. I open the prompt
[09:03] (543.84s)
box, select the exact element I want to
[09:06] (546.08s)
change and write precisely what I want,
[09:08] (548.16s)
like adding a proper hover animation and
[09:10] (550.40s)
making it consistent with the rest of
[09:12] (552.00s)
the UI. When I send that prompt and go
[09:14] (554.16s)
back to cursor, you'll see something
[09:15] (555.92s)
amazing. It includes all the accurate
[09:18] (558.08s)
data, the element's exact location in
[09:20] (560.32s)
the code, what I want changed, and other
[09:22] (562.48s)
useful context information. I send the
[09:24] (564.80s)
prompt, and as you can see, the button
[09:26] (566.72s)
has been updated perfectly. It now
[09:28] (568.80s)
matches the rest of the UI with this
[09:30] (570.64s)
yellowish theme. And when I hover over
[09:32] (572.72s)
it, there's a subtle animation. And this
[09:34] (574.96s)
is exactly what I wanted. This level of
[09:37] (577.28s)
precision is what separates amateur
[09:39] (579.44s)
projects from professional ones. And
[09:41] (581.28s)
Stage Wise makes it accessible to
[09:43] (583.12s)
everyone. That brings us to the end of
[09:45] (585.28s)
this video. If you missed my previous
[09:47] (587.20s)
video on three ways you can build a
[09:49] (589.44s)
beautiful website using cursor, the one
[09:51] (591.84s)
I've been referencing throughout,
[09:53] (593.44s)
definitely check that out as well to get
[09:55] (595.36s)
the full picture. If you found these
[09:57] (597.04s)
methods helpful and want to support the
[09:59] (599.12s)
channel, you can use the super thanks
[10:00] (600.80s)
button below. It really helps us keep
[10:02] (602.80s)
making tutorials like this. Thanks for
[10:04] (604.72s)
watching and I'll see you in the next