[00:00] (0.16s)
Your site's UI is everything. It's what
[00:02] (2.56s)
users interact with and how they judge
[00:04] (4.56s)
your entire project. And even with AI
[00:06] (6.56s)
tools like Cursor, you still need to
[00:08] (8.40s)
know how to build proper UI if you want
[00:10] (10.48s)
something that looks professional. Shad
[00:12] (12.40s)
CN components are some of the most
[00:14] (14.24s)
popular React components out there and
[00:16] (16.32s)
for good reason. But here's the thing,
[00:17] (17.92s)
you're probably using them wrong. I used
[00:19] (19.68s)
to just tell Cursor, build this with
[00:21] (21.44s)
Shad CN, and hope for the best. But
[00:23] (23.52s)
Cursor consistently messes up the
[00:25] (25.36s)
implementation, leaving you with broken
[00:27] (27.36s)
components and styling issues. So today
[00:29] (29.60s)
I'll show you how to implement these
[00:31] (31.20s)
components properly and style them so
[00:33] (33.12s)
your site actually looks unique instead
[00:35] (35.04s)
of like every other Shadcen site out
[00:37] (37.12s)
there. To get this right, you need the
[00:39] (39.12s)
proper workflow. And I found something
[00:40] (40.88s)
that's completely changed how I work
[00:42] (42.72s)
with Shad CNN. This MCP server built
[00:45] (45.28s)
specifically for Shad Cn UI. This MCP
[00:48] (48.24s)
server has transformed my development
[00:50] (50.24s)
process. It provides proper context and
[00:52] (52.72s)
implementation patterns ensuring
[00:54] (54.72s)
everything works correctly from the
[00:56] (56.48s)
start. There's one tool in this MCP
[00:58] (58.64s)
server that's been a total gamecher for
[01:00] (60.80s)
me. Let me show you the GitHub repo and
[01:02] (62.96s)
walk you through how this works. If you
[01:05] (65.12s)
scroll down, there are basically two
[01:06] (66.96s)
ways to use it. One is without your
[01:08] (68.88s)
GitHub personal access token, and the
[01:11] (71.04s)
second is with it. If you do use your
[01:12] (72.88s)
personal access token, you'll get 5,000
[01:15] (75.28s)
requests per hour. So, I definitely
[01:17] (77.36s)
recommend getting your token. I'll even
[01:19] (79.28s)
show you how to install and set it up.
[01:20] (80.88s)
But, if I go into cursor, I already have
[01:22] (82.64s)
it set up. And you can see that I have
[01:24] (84.32s)
the Shad CN UI MCP server right here.
[01:27] (87.92s)
Let me guide you through the workflow
[01:29] (89.52s)
I've developed using the Shad CN UI MCP
[01:32] (92.48s)
server and show you how this has
[01:34] (94.16s)
completely transformed the way I
[01:35] (95.84s)
approach building frontends. So, first
[01:37] (97.84s)
let me show you this MCP store.md file.
[01:41] (101.04s)
What you're looking at here is a
[01:42] (102.48s)
complete UI UX implementation for a demo
[01:45] (105.44s)
MCP store and it includes not just the
[01:47] (107.92s)
structure but the entire user journey as
[01:50] (110.16s)
well. The way this came about was pretty
[01:52] (112.00s)
simple. I went to Claude, brainstormed
[01:54] (114.08s)
my idea and asked it to generate the
[01:56] (116.32s)
whole implementation plan for me and
[01:58] (118.32s)
this is what it came up with. Now what's
[02:00] (120.00s)
important to understand here is that
[02:01] (121.52s)
this is purely the UI and UX
[02:03] (123.44s)
implementation. It doesn't contain any
[02:05] (125.36s)
code implementations or anything like
[02:07] (127.12s)
that at this stage. So now let me take
[02:09] (129.04s)
you back to the MCP tools and I'll show
[02:11] (131.20s)
you the tool that I mentioned was the
[02:13] (133.12s)
real gamecher. First there's the list
[02:15] (135.44s)
components tool which returns all of the
[02:17] (137.68s)
available components. We're talking
[02:19] (139.36s)
about 46 total components. Then we have
[02:22] (142.08s)
the get component tool which does
[02:24] (144.00s)
exactly what you'd expect. It gets
[02:25] (145.92s)
information about a single component.
[02:28] (148.00s)
But then there's the get component demo
[02:30] (150.08s)
tool. And this is the game changer I
[02:32] (152.40s)
mentioned earlier. This tool has
[02:34] (154.32s)
honestly been revolutionary for my
[02:36] (156.24s)
workflow and has solved so many errors
[02:38] (158.40s)
for me. So let me show you a
[02:39] (159.92s)
demonstration of how this works. You can
[02:42] (162.08s)
see right here that I asked it to use
[02:44] (164.00s)
the demo tool for a component and
[02:46] (166.16s)
explain how it was used simply because I
[02:48] (168.48s)
was curious about it. and it went ahead
[02:50] (170.16s)
and listed all the components for me.
[02:52] (172.08s)
Then retrieved the component demos,
[02:53] (173.92s)
which is where the magic happens. Take
[02:55] (175.60s)
the button component. That one's pretty
[02:57] (177.60s)
simple to implement. So you might not
[02:59] (179.28s)
need the demo tool as much there. But
[03:01] (181.28s)
then take the dialogue component, and
[03:03] (183.20s)
this is where it really shines. You'll
[03:05] (185.04s)
see there's a specific way it needs to
[03:07] (187.04s)
be implemented. And here's what makes
[03:08] (188.88s)
this so powerful. The component demos
[03:11] (191.28s)
show you exactly how it's used in real
[03:13] (193.44s)
code. So there's virtually no chance of
[03:15] (195.68s)
making errors because you have the exact
[03:17] (197.84s)
usage patterns right there. Coming back
[03:19] (199.92s)
to the other tools, we also have
[03:21] (201.60s)
something called blocks. Now blocks are
[03:23] (203.52s)
quite different. They're combinations of
[03:25] (205.36s)
components used together. So for
[03:27] (207.20s)
example, a login block isn't just a
[03:29] (209.52s)
single component. It's actually a mix of
[03:32] (212.00s)
multiple components working together.
[03:34] (214.00s)
The list blocks and get blocks tools are
[03:36] (216.00s)
designed specifically to handle these
[03:37] (217.92s)
more complex elements. So those were the
[03:39] (219.92s)
main tools. Now, let me show you how I
[03:41] (221.68s)
actually use the Shad CN UI MCP in my
[03:44] (224.16s)
day-to-day workflow. The key is that I
[03:46] (226.08s)
use rule files because they're
[03:47] (227.68s)
essentially a way to program your AI
[03:49] (229.52s)
agent, right? So, here was my first
[03:51] (231.12s)
rule. Whenever it's asked to work with
[03:53] (233.04s)
Shad CNUI components, the system should
[03:55] (235.44s)
automatically use the MCP server. Then,
[03:57] (237.92s)
whenever I'm planning anything related
[03:59] (239.52s)
to Shad CN, and I'll show you what this
[04:01] (241.44s)
looks like in a moment. During that
[04:03] (243.12s)
planning phase, it should apply existing
[04:05] (245.28s)
components wherever possible. And if
[04:07] (247.20s)
blocks can be used instead, it should
[04:09] (249.04s)
prioritize those because blocks are
[04:11] (251.04s)
already pre-made and the MCP already has
[04:13] (253.20s)
full context for them. The third rule
[04:15] (255.04s)
covers implementation. When we're
[04:16] (256.88s)
actually building the components, it
[04:18] (258.80s)
should call the demo tool first. That's
[04:20] (260.96s)
really important. It needs to check how
[04:22] (262.88s)
the component is properly used and then
[04:25] (265.28s)
use that information in the actual code.
[04:27] (267.60s)
So that's the foundation I set up. And
[04:29] (269.44s)
then I referenced this rule file. You
[04:31] (271.28s)
can see it right there. And I asked
[04:32] (272.88s)
Claude to look at the MCP store.md file.
[04:36] (276.00s)
This is what it examined. This complete
[04:38] (278.08s)
implementation plan you're seeing here
[04:40] (280.00s)
that Claude generated for me. What I
[04:42] (282.16s)
specifically asked it to do was create a
[04:44] (284.72s)
UI implementation using shad CN UI that
[04:48] (288.16s)
would tell us exactly what components
[04:50] (290.16s)
will be used in the UI structure and
[04:52] (292.16s)
precisely where they'll be placed. I
[04:54] (294.00s)
wanted it to only mention the
[04:55] (295.60s)
appropriate component names. No actual
[04:58] (298.24s)
code at this stage because this part
[05:00] (300.32s)
isn't about coding yet. In a way, we're
[05:02] (302.72s)
returning to the concept of context
[05:04] (304.56s)
engineering, but this time it's
[05:06] (306.24s)
specifically optimized for front-end
[05:08] (308.24s)
development. So, cursor went ahead and
[05:10] (310.32s)
listed components, listed blocks, and
[05:12] (312.56s)
retrieved all the different pieces we
[05:14] (314.48s)
needed. Then, once all of that
[05:16] (316.16s)
groundwork was complete, I asked it to
[05:18] (318.24s)
compile everything into this
[05:19] (319.76s)
implementation plan. Now, if we look at
[05:22] (322.08s)
what's actually being built right now,
[05:24] (324.08s)
you'll see that I referenced the rule
[05:25] (325.84s)
file again and told cursor to implement
[05:28] (328.24s)
this plan inside the Shad CN app. As the
[05:31] (331.44s)
system works through the process, it's
[05:33] (333.36s)
adding all the components step by step,
[05:35] (335.84s)
building everything methodically. Here's
[05:37] (337.76s)
what's fascinating. Once it finishes
[05:39] (339.60s)
with a specific set of blocks and
[05:41] (341.44s)
components, it calls the tools again.
[05:43] (343.44s)
And this happens because that's exactly
[05:45] (345.44s)
how it's programmed in the rule file.
[05:47] (347.52s)
Because of that programming, it never
[05:49] (349.28s)
strays from the process. It consistently
[05:51] (351.44s)
fetches the context first. And this is
[05:53] (353.28s)
the crucial part we've been exploring
[05:54] (354.88s)
with context engineering. And this is
[05:57] (357.12s)
what it came up with. You can see it
[05:58] (358.72s)
looks really professional and all the
[06:00] (360.40s)
components have been implemented
[06:02] (362.00s)
perfectly. This was done in one single
[06:04] (364.00s)
try. I just had to go back once because
[06:06] (366.08s)
of some configuration issues. But if I
[06:08] (368.08s)
had done this without the MCP server,
[06:10] (370.24s)
there would have been so many component
[06:11] (371.84s)
issues and responsive issues that I'd
[06:13] (373.68s)
have to go back and deal with them again
[06:15] (375.44s)
and again. Also, if I go back and show
[06:17] (377.60s)
you the login page, you can see that
[06:19] (379.60s)
this is a single block and the dashboard
[06:21] (381.68s)
that you see here is also a single block
[06:23] (383.84s)
that's been modified to add many more
[06:26] (386.08s)
components. So using the MCP server and
[06:28] (388.80s)
the workflow of already making a plan
[06:30] (390.88s)
for how the implementation should be
[06:32] (392.64s)
done with the shad C and UI components.
[06:34] (394.96s)
This is what makes the whole process so
[06:36] (396.80s)
effective. Oh, and if you're enjoying
[06:38] (398.72s)
the content, please hit that subscribe
[06:40] (400.56s)
button. We've also launched channel
[06:42] (402.24s)
memberships. 97 people have already
[06:44] (404.40s)
joined our first tier. Members get
[06:46] (406.16s)
priority replies to comments. So if you
[06:48] (408.32s)
need feedback or have questions, that's
[06:50] (410.24s)
the best way to reach us. We're
[06:51] (411.68s)
considering adding more tiers based on
[06:53] (413.60s)
the incredible support so far. So, I
[06:56] (416.24s)
just showed you how you can create a
[06:58] (418.00s)
better structure for your sites using
[06:59] (419.84s)
the MCP server. Now, let's talk about
[07:02] (422.32s)
how you can customize your site using
[07:04] (424.32s)
the Shad CN UI components. For that,
[07:06] (426.96s)
we're going to be using this site called
[07:08] (428.64s)
Tweak CN. I've actually featured it in
[07:10] (430.72s)
previous videos, and it's just a really
[07:12] (432.56s)
amazing site. If I open it up, you'll
[07:14] (434.64s)
see that it's essentially a customizer
[07:16] (436.56s)
for the base Shad CN UI components. And
[07:19] (439.04s)
if I go ahead and switch things up here,
[07:20] (440.96s)
I can change the designs. And whichever
[07:22] (442.80s)
one I like, I can go ahead and
[07:24] (444.40s)
implement. And these aren't just
[07:25] (445.76s)
pre-made designs. You can fully
[07:27] (447.60s)
customize them however you want. All the
[07:29] (449.60s)
settings are right here. So, just go
[07:31] (451.04s)
ahead and tweak them however you like so
[07:32] (452.96s)
that your site or web app gets a unified
[07:35] (455.52s)
look that's truly your own. Because, you
[07:37] (457.36s)
know, a lot of websites built with Shad
[07:39] (459.44s)
CN tend to look really similar. There's
[07:41] (461.60s)
not much visual customization out of the
[07:43] (463.76s)
box. But with this, you can actually
[07:45] (465.68s)
design something that feels unique. Once
[07:48] (468.00s)
you land on something you really like,
[07:49] (469.84s)
just go into the code option, copy the
[07:51] (471.84s)
command, and give it to cursor to
[07:53] (473.44s)
install the theme. Now, I've seen that
[07:55] (475.28s)
sometimes cursor isn't able to fully
[07:57] (477.36s)
install it automatically. If that
[07:59] (479.20s)
happens, just copy the code shown below.
[08:01] (481.44s)
These are all the small settings you'll
[08:03] (483.28s)
need to change to match the theme you
[08:05] (485.04s)
created. You can give this to cursor and
[08:07] (487.04s)
it will modify the files directly and
[08:09] (489.12s)
then you'll have the exact theme you
[08:10] (490.88s)
customized. So, first you build your
[08:13] (493.04s)
entire structure perfecting it using the
[08:15] (495.28s)
MCP server and that part doesn't take
[08:17] (497.60s)
much time. Then once that's done, you
[08:20] (500.00s)
use tweak CN to make everything look
[08:22] (502.16s)
great. So the installation is actually
[08:24] (504.48s)
pretty easy. Back in the GitHub
[08:26] (506.16s)
repository, if you scroll down, you'll
[08:28] (508.32s)
find the MCP configuration. They have
[08:30] (510.48s)
different ways of testing and also
[08:32] (512.16s)
running the MCP server. But for running
[08:34] (514.16s)
it with cloud code or cursor on
[08:35] (515.92s)
Windinsurf, you're going to need to use
[08:37] (517.60s)
the claw desktop configuration. So we're
[08:40] (520.00s)
just going to go ahead and copy it. Then
[08:41] (521.84s)
head back into cursor, open up the
[08:43] (523.76s)
settings, and go inside tools and
[08:45] (525.60s)
integrations here. When it's not added
[08:47] (527.60s)
yet, you're going to go in and just add
[08:49] (529.44s)
the MCP server. Now, as you can see,
[08:51] (531.92s)
I've added the MCP server without the
[08:54] (534.00s)
GitHub personal access token, but you
[08:56] (536.24s)
definitely want the increased user
[08:57] (537.84s)
limit. So, I highly recommend that you
[09:00] (540.08s)
go ahead and get your personal access
[09:01] (541.92s)
token. It's really easy to get. Once you
[09:04] (544.08s)
get your token, make sure to copy it
[09:05] (545.76s)
because you won't be able to see it
[09:07] (547.20s)
again. Then, go back, paste it here,
[09:09] (549.12s)
save your MCP file, and you're ready to
[09:11] (551.20s)
go. That brings us to the end of this
[09:13] (553.20s)
video. If you'd like to support the
[09:14] (554.80s)
channel and help us keep making videos
[09:16] (556.64s)
like this, you can do so by using the
[09:18] (558.56s)
super thanks button below. As always,
[09:20] (560.64s)
thank you for watching and I'll see you
[09:22] (562.16s)
in the next one.