[00:00] (0.08s)
I really love Claude Code. The coding
[00:02] (2.00s)
agent that Anthropic has built gives you
[00:03] (3.92s)
so much customization that it's crazy,
[00:05] (5.92s)
but I keep finding new custom ways to
[00:07] (7.84s)
make it even better. Today, I want to
[00:09] (9.52s)
show you two free tools that supercharge
[00:11] (11.52s)
Claude Code and may change how you use
[00:13] (13.44s)
it. Both tools are completely free, and
[00:15] (15.52s)
I think you're going to love what they
[00:16] (16.96s)
can do. Let's jump right in. You know
[00:18] (18.88s)
that Claude Code gives you an extreme
[00:21] (21.04s)
level of customization. It has these
[00:23] (23.20s)
custom commands and you can even modify
[00:25] (25.52s)
the claw.md file to turn it into an
[00:28] (28.32s)
agent specialized for your specific
[00:30] (30.32s)
task. You can create workflows, but
[00:32] (32.40s)
these workflows need to be tested and
[00:34] (34.40s)
take a lot of time to create by
[00:35] (35.92s)
yourself, especially if you're a Vibe
[00:37] (37.76s)
coder who doesn't know the full
[00:39] (39.20s)
development process. In that case, you
[00:41] (41.20s)
won't be able to make them very well.
[00:42] (42.96s)
This is where the first tool I want to
[00:44] (44.56s)
show you comes in. It's a configuration
[00:46] (46.56s)
framework, as the author calls it. And
[00:48] (48.56s)
the funny thing is, it's even called
[00:50] (50.48s)
Super Cloud. Basically, it allows Claude
[00:52] (52.96s)
code to gain a new set of abilities and
[00:55] (55.20s)
skills that take it to the next level.
[00:57] (57.20s)
And it'll be clear what I mean in just a
[00:59] (59.20s)
minute. Now, what does it give you? It
[01:01] (61.20s)
provides 18 structured commands and
[01:03] (63.52s)
they're all focused on one thing. Then
[01:05] (65.36s)
there are flags. When used with the
[01:07] (67.20s)
commands, the flags give you additional
[01:09] (69.20s)
functionality. For example, it has this
[01:11] (71.52s)
persona flag and you can choose between
[01:13] (73.52s)
nine of them. They all represent a
[01:15] (75.36s)
specific part of the development life
[01:17] (77.12s)
cycle. That in itself is an amazing
[01:19] (79.44s)
feature. Like if you wanted to build you
[01:21] (81.20s)
a landing page or a UI component, you
[01:23] (83.60s)
can implement the front-end persona for
[01:25] (85.44s)
that. And there are personas for
[01:27] (87.04s)
literally everything for architecture
[01:29] (89.04s)
planning, for backend, for security, and
[01:31] (91.20s)
for analyzing different problems. It's
[01:33] (93.20s)
really crazy. Now, how does this work? I
[01:35] (95.52s)
opened it up and took a look. On the
[01:37] (97.20s)
back end, the developer has written
[01:39] (99.12s)
configuration files in the form of
[01:41] (101.04s)
custom commands and even a set of rules
[01:43] (103.36s)
and configured workflows in the form of
[01:45] (105.44s)
YAML files. So, in a way, it's all just
[01:47] (107.76s)
prompting, but that's how you program AI
[01:50] (110.16s)
agents and models. For example, in the
[01:52] (112.24s)
front-end persona, it gives Claude a
[01:54] (114.40s)
really robust workflow that's super
[01:56] (116.48s)
beneficial for creating UI. And the
[01:58] (118.48s)
workflows that the author has written
[02:00] (120.32s)
give Claude code the context on how real
[02:02] (122.72s)
developers go through the development
[02:04] (124.48s)
cycle. So, it has context for the whole
[02:06] (126.64s)
development cycle, and it's all written
[02:08] (128.48s)
out. You just need to learn how to use
[02:10] (130.48s)
the relevant tags at the relevant time.
[02:12] (132.88s)
And not only that, it actually takes
[02:14] (134.64s)
advantage of MCPs as well. You can see
[02:16] (136.88s)
we have the context 7 MCP which gets
[02:19] (139.52s)
external documentation, the sequential
[02:21] (141.84s)
MCP which basically allows multi-step
[02:24] (144.40s)
reasoning and then the magic UI MCP and
[02:27] (147.04s)
Puppeteer MCP as well which are really
[02:29] (149.28s)
great. Also, if I open the claw.md file,
[02:32] (152.32s)
the whole configuration has been set up
[02:34] (154.16s)
on how to actually use everything. So,
[02:36] (156.24s)
this is why it's called super claude. To
[02:38] (158.16s)
give you an example of how the slash
[02:40] (160.00s)
commands and the flags are used, if I
[02:42] (162.16s)
scroll down, you can see that we have
[02:44] (164.16s)
workflows like the /build command
[02:46] (166.40s)
followed by flags like react, which
[02:48] (168.48s)
means to use react, magic, which means
[02:50] (170.80s)
to use the magic mcp, and watch, which
[02:53] (173.52s)
means it will monitor development
[02:55] (175.28s)
continuously. You can also see the
[02:56] (176.96s)
persona has been set with the persona
[02:59] (179.04s)
front-end flag. Now, all of this is
[03:00] (180.96s)
super powerful, but I found one problem
[03:03] (183.12s)
the author really should have taken care
[03:04] (184.88s)
of, and that's that there's no proper
[03:06] (186.80s)
way to learn to use this. When I
[03:08] (188.48s)
installed it and watched other videos
[03:10] (190.24s)
from YouTubers, they all just demoed it.
[03:12] (192.64s)
I basically found no proper guide on how
[03:14] (194.80s)
to actually use it. That creates a bit
[03:16] (196.48s)
of a problem because there's a learning
[03:17] (197.92s)
curve with this tool given the amount of
[03:20] (200.08s)
flags and tools in this. Even if you
[03:22] (202.00s)
could figure it out, you'd still need to
[03:23] (203.84s)
learn the commands, the available
[03:25] (205.52s)
personas, and where to add the different
[03:27] (207.44s)
MCPS. But not to worry, I found a
[03:29] (209.60s)
workaround for this problem. I opened
[03:31] (211.44s)
this folder with the configuration in
[03:33] (213.36s)
cursor. I'll show you how I installed it
[03:35] (215.36s)
later in the video, but right now you
[03:37] (217.44s)
just need to know that the configuration
[03:39] (219.28s)
was installed in this folder. I used
[03:41] (221.28s)
this command and it opened up in cursor.
[03:43] (223.52s)
Now going back to cursor, since all the
[03:45] (225.76s)
commands were there, what I did was ask
[03:47] (227.84s)
cursor to go ahead read all the
[03:49] (229.84s)
configuration files, all of them, and
[03:52] (232.08s)
make me a comprehensive guide on how to
[03:54] (234.24s)
use them with claude and when and where.
[03:56] (236.80s)
Those are the important parts. It read
[03:58] (238.96s)
through all of it and Cursor's new
[04:00] (240.72s)
search tool is really, really amazing.
[04:02] (242.80s)
They've posted some results on how much
[04:04] (244.72s)
better it is at finding stuff and it's
[04:06] (246.72s)
using that model. It found everything
[04:08] (248.72s)
super easily, made the connections
[04:10] (250.64s)
between files and gave me a really cool
[04:12] (252.80s)
configuration guide. Now, I didn't want
[04:15] (255.04s)
to learn all the commands and flags by
[04:17] (257.04s)
myself. Since it had generated the full
[04:19] (259.20s)
documentation, I thought, why not create
[04:21] (261.36s)
documentation that I can feed to an AI
[04:23] (263.60s)
agent in clawed code or cursor? That way
[04:26] (266.24s)
the agent can tell me the best way to
[04:28] (268.16s)
use these commands for my specific use
[04:30] (270.08s)
case. So I told cursor to put everything
[04:32] (272.16s)
into the docs.md file which you can see
[04:34] (274.72s)
right here. It created a comprehensive
[04:36] (276.80s)
file of around 450 words. Once I had
[04:39] (279.68s)
this documentation ready, I gave it a
[04:41] (281.68s)
task. I said I wanted to build a next.js
[04:44] (284.08s)
app with 11 Labs API integration and the
[04:46] (286.96s)
open AI API. The idea was to create a
[04:49] (289.44s)
story generator that also has a
[04:51] (291.20s)
narration feature. I asked cursor what
[04:53] (293.36s)
workflow I should follow based on the
[04:55] (295.12s)
framework. Now due to some limitations I
[04:57] (297.84s)
couldn't set up the magic mcp and
[05:00] (300.00s)
puppeteer mcp right away. So I asked
[05:02] (302.64s)
cursor not to use them in the flags. You
[05:04] (304.96s)
still have to configure the mcps
[05:06] (306.72s)
yourself in claude code. The framework
[05:08] (308.72s)
simply tells you where they belong in
[05:10] (310.72s)
each workflow. But using the right
[05:12] (312.48s)
commands claude knows when to apply each
[05:14] (314.80s)
tool which is still incredibly powerful.
[05:17] (317.28s)
Here's what happened next. Cursor gave
[05:19] (319.04s)
me the commands but it was missing the
[05:20] (320.88s)
prompts. I realized cursor didn't know
[05:22] (322.96s)
it needed to include both the commands
[05:24] (324.88s)
and prompts together for clawed code. So
[05:27] (327.04s)
I told it to output the slash commands,
[05:29] (329.28s)
flags, and prompts in a structured way.
[05:31] (331.28s)
And it delivered exactly that. Phase 1,
[05:33] (333.76s)
phase 2, phase 3, all the way to phase
[05:36] (336.56s)
11 for deployment. A complete project
[05:38] (338.96s)
outline. Remember this framework
[05:40] (340.88s)
includes commands and workflows for
[05:42] (342.88s)
every step of the developer cycle. And
[05:45] (345.04s)
now cursor knows all of it. The beauty
[05:47] (347.20s)
is it's not limited to cursor. You can
[05:49] (349.52s)
copy the documentation, feed it to
[05:51] (351.44s)
Claude code, and Claude will generate
[05:53] (353.44s)
structured workflows for you. If you've
[05:55] (355.36s)
seen my video on context engineering,
[05:57] (357.52s)
you know these workflows are evolving
[05:59] (359.28s)
quickly. People once thought
[06:00] (360.80s)
non-developers couldn't build
[06:02] (362.40s)
applications. But development knowledge
[06:04] (364.48s)
can be embedded into frameworks like
[06:06] (366.40s)
this and shared openly. Now, anyone,
[06:09] (369.12s)
even Vibe coders with little industry
[06:11] (371.28s)
experience, can follow a guided workflow
[06:13] (373.68s)
written by someone who does know the
[06:15] (375.44s)
process. And speaking of sharing, I'll
[06:17] (377.44s)
leave this documentation that cursor
[06:19] (379.44s)
created for me in the description below
[06:21] (381.60s)
so you can use it for yourself as well.
[06:23] (383.52s)
So back to the demonstration. Phase one
[06:25] (385.92s)
is analysis and research. I'll copy the
[06:28] (388.48s)
command with its flags and switch to my
[06:30] (390.64s)
terminal. When I open the slash menu in
[06:32] (392.80s)
Claude, you'll see all the extra
[06:34] (394.40s)
commands from this framework listed
[06:36] (396.32s)
above Claude's original commands. Those
[06:38] (398.56s)
start with add directory. I'll paste the
[06:40] (400.80s)
command and its flags here, then copy
[06:42] (402.80s)
the accompanying prompt. You can
[06:44] (404.32s)
customize that prompt if cursor added
[06:46] (406.48s)
extra wording. It's all just context for
[06:48] (408.48s)
the model and it will output structured
[06:50] (410.48s)
commands automatically. No need to
[06:52] (412.32s)
memorize everything. Learning it all
[06:54] (414.08s)
would take way too much time. When I hit
[06:56] (416.08s)
enter, you'll see Claude start to run.
[06:58] (418.08s)
If I scroll up, you can watch the
[06:59] (419.76s)
workflow kick in. Claude recognizes this
[07:02] (422.00s)
as a research task, knows which tools to
[07:04] (424.32s)
use, like context 7 for external
[07:06] (426.40s)
documentation, then creates to-dos. It's
[07:08] (428.88s)
using sequential MCP. Asks my permission
[07:11] (431.36s)
to call the tool and proceeds. It's all
[07:13] (433.60s)
just a workflow, nothing fundamentally
[07:15] (435.52s)
new. But these workflows are packaged
[07:17] (437.44s)
for you by the framework's author. As I
[07:19] (439.52s)
mentioned earlier, you don't need to
[07:21] (441.04s)
learn every detail. Just create the
[07:22] (442.96s)
documentation and go. You can see the
[07:24] (444.96s)
entire development cycle spelled out
[07:26] (446.80s)
right here, and you can do plenty of
[07:28] (448.48s)
creative things with it. Again, I'll
[07:30] (450.24s)
include the complete documentation in
[07:32] (452.16s)
the description, so you can skip the
[07:34] (454.08s)
setup process and start using these
[07:36] (456.08s)
workflows immediately. Oh, and if you're
[07:38] (458.72s)
enjoying the content we're making, I'd
[07:40] (460.72s)
really appreciate it if you hit that
[07:42] (462.40s)
subscribe button. We're also testing out
[07:44] (464.40s)
channel memberships. Launch the first
[07:46] (466.16s)
tier as a test, and 93 people have
[07:48] (468.56s)
joined so far. The support's been
[07:50] (470.32s)
incredible, so we're thinking about
[07:52] (472.00s)
launching additional tiers. Right now,
[07:54] (474.32s)
members get priority replies to their
[07:56] (476.48s)
comments. Perfect if you need feedback
[07:58] (478.40s)
or have questions. Now, what if you
[08:00] (480.56s)
could access Claude Code from anywhere,
[08:02] (482.80s)
like any device? That's where the second
[08:04] (484.72s)
tool comes in. It's essentially a
[08:06] (486.48s)
web-based GUI for Claude Code. I
[08:09] (489.20s)
previously covered another GUI called
[08:11] (491.52s)
Claudia in an earlier video. The
[08:13] (493.60s)
difference is that Claudia was more
[08:15] (495.44s)
complex and featurerich with a superior
[08:17] (497.84s)
interface. This tool offers something
[08:19] (499.84s)
entirely different, browser
[08:21] (501.44s)
accessibility from any device. So,
[08:23] (503.52s)
Claude Code and my projects could be
[08:25] (505.60s)
running on my computer while I'm
[08:27] (507.36s)
actually using Claude Code through a
[08:29] (509.20s)
browser on my mobile. That's incredibly
[08:31] (511.44s)
powerful and the setup is surprisingly
[08:33] (513.68s)
simple. You just copy this script for
[08:35] (515.52s)
the installation. Also, don't worry
[08:37] (517.52s)
about the super cloud installation. I'll
[08:39] (519.52s)
cover that at the end. Now, this is
[08:41] (521.36s)
basically an executable app. Navigate to
[08:43] (523.84s)
where you want it installed. For
[08:45] (525.36s)
example, I'm in the claude web UI folder
[08:47] (527.84s)
where I've placed the executable. Run
[08:49] (529.76s)
the script. It handles everything for
[08:51] (531.52s)
you. Paste it in the correct location
[08:53] (533.52s)
and you're ready to launch it. There are
[08:55] (535.36s)
different startup methods. The default
[08:57] (537.36s)
command launches it on localhost 8080
[09:00] (540.08s)
which only runs locally on your
[09:01] (541.76s)
computer. But this lacks the network
[09:03] (543.52s)
capabilities I'm describing. To make it
[09:05] (545.84s)
accessible from anywhere on your
[09:07] (547.36s)
network, use this command instead. Let
[09:09] (549.52s)
me copy this. Go back to terminal and
[09:11] (551.84s)
paste it. There's a small documentation
[09:14] (554.00s)
error. The full executable name isn't
[09:16] (556.16s)
shown. So use the ls command like I did
[09:18] (558.48s)
to correct it. You'll see the proper
[09:20] (560.08s)
executable name and it'll launch. Now
[09:22] (562.16s)
how do you connect from other devices?
[09:24] (564.24s)
It's running on the network. So to
[09:26] (566.08s)
connect from different devices, you need
[09:28] (568.16s)
your IP address for the current network.
[09:30] (570.56s)
You'll need a separate command for this.
[09:32] (572.48s)
You can ask chatgpt or use the one I
[09:35] (575.12s)
used here. Warp provided it and it gave
[09:37] (577.60s)
me my IP address. Once you have this IP
[09:40] (580.00s)
address, return to where the web UI is
[09:42] (582.16s)
running. Copy the port number. Open your
[09:44] (584.32s)
browser. This works on any device,
[09:46] (586.48s)
mobile, another computer. They just need
[09:48] (588.64s)
to be on the same network. I'm
[09:50] (590.24s)
demonstrating on my own computer, but it
[09:52] (592.32s)
works on any device connected to the
[09:54] (594.16s)
same network via browser. Paste it in,
[09:56] (596.48s)
remove the zeros, and add your IP
[09:58] (598.40s)
address. And there's your web UI. It's
[10:00] (600.56s)
quite basic, nothing fancy. You can
[10:02] (602.48s)
create new directories or select
[10:04] (604.32s)
existing projects. In existing projects,
[10:06] (606.56s)
you can chat with Claude Code and it'll
[10:08] (608.56s)
start working. You can see it's
[10:10] (610.00s)
initialized here. The amazing part is
[10:11] (611.84s)
cross device accessibility. I use this
[10:14] (614.08s)
to run Claude code from anywhere in the
[10:16] (616.00s)
house. I just pull it up on my phone and
[10:18] (618.08s)
use clawed code directly from there.
[10:19] (619.92s)
It's genuinely useful and I thought it
[10:21] (621.92s)
was worth sharing. Beyond that, it
[10:23] (623.76s)
doesn't have special features. I even
[10:25] (625.68s)
tried/comands, but those don't work. So,
[10:28] (628.24s)
unfortunately, the supercloud
[10:30] (630.00s)
configuration won't function here.
[10:31] (631.76s)
Still, it's a pretty cool tool you can
[10:33] (633.76s)
utilize. Now, for the installation of
[10:36] (636.24s)
supercloud installed, you need to head
[10:38] (638.24s)
over to its GitHub repo where you'll
[10:40] (640.24s)
find the installer. Simply copy these
[10:42] (642.32s)
lines and paste them wherever you want
[10:44] (644.24s)
the framework downloaded. This will
[10:46] (646.08s)
clone the repository to your system.
[10:48] (648.16s)
Once that's done, navigate into the
[10:50] (650.24s)
folder and you'll see the install
[10:52] (652.16s)
script. This is what handles everything
[10:54] (654.24s)
for us. Now you've got two installation
[10:56] (656.40s)
options. The first is global
[10:58] (658.32s)
installation. This means every instance
[11:00] (660.48s)
of claude code will have access to super
[11:02] (662.96s)
cloud. The second option is project
[11:04] (664.88s)
specific installation. You'll have to
[11:06] (666.72s)
use this command instead and you'll
[11:08] (668.64s)
remove this part here and replace it
[11:10] (670.48s)
with your actual folder path such as you
[11:12] (672.48s)
can see that I have entered. Here's the
[11:14] (674.16s)
key thing to remember. Whatever folder
[11:16] (676.08s)
you're targeting, you need to add.claude
[11:18] (678.40s)
to the end of the path, just like I've
[11:20] (680.24s)
added it here. The configuration files
[11:22] (682.32s)
need to be inside that do.claude folder.
[11:24] (684.80s)
If you're going with the global option,
[11:26] (686.56s)
just make sure to clear out your
[11:27] (687.92s)
existing.cloud folder first, then run
[11:30] (690.24s)
the installation script. That brings us
[11:32] (692.56s)
to the end of this video. If you'd like
[11:34] (694.32s)
to support the channel and help us keep
[11:36] (696.32s)
making videos like this, you can do so
[11:38] (698.32s)
by using the super thanks button below.
[11:40] (700.48s)
As always, thank you for watching and
[11:42] (702.16s)
I'll see you in the next one.