[00:00] (0.16s)
Everyone's saying that claude code is so
[00:02] (2.32s)
much better and they're absolutely
[00:03] (3.84s)
right. Claude code gives you the full
[00:05] (5.92s)
context window that gets restricted when
[00:08] (8.16s)
you use those same models through
[00:09] (9.92s)
cursor. This means you get significantly
[00:12] (12.08s)
more powerful AI coding performance.
[00:14] (14.32s)
Plus, it's incredibly affordable now
[00:16] (16.32s)
that it works with just the $20 pro
[00:18] (18.56s)
plan. So, why haven't I switched yet?
[00:20] (20.88s)
Because despite all this power, there
[00:22] (22.72s)
have been some major deal breakers that
[00:24] (24.72s)
kept me stuck on cursor. Issues so
[00:26] (26.80s)
frustrating that no matter how good
[00:28] (28.56s)
Claude Code's performance was, I just
[00:30] (30.56s)
couldn't make it my daily driver. But
[00:32] (32.32s)
that just changed completely. I just
[00:34] (34.24s)
discovered something that doesn't just
[00:36] (36.00s)
solve these problems. It finally makes
[00:38] (38.08s)
Claude Code the complete package I've
[00:40] (40.08s)
been waiting for. And once you see what
[00:41] (41.76s)
this is, you'll understand why this
[00:43] (43.68s)
changes everything. Now, this tool
[00:45] (45.68s)
transforms Claude Code in two major
[00:47] (47.52s)
ways, but there's so much more to it
[00:49] (49.28s)
than that. I'll also show you additional
[00:51] (51.20s)
features that will make switching to
[00:52] (52.80s)
Claude Code with this integrated tool
[00:54] (54.96s)
irresistible. Now, one of the biggest
[00:57] (57.52s)
advantages that Cursor had over Claude
[00:59] (59.76s)
Code was its incredible GUI that made
[01:02] (62.56s)
everything so much more accessible. You
[01:04] (64.88s)
could easily add features without any
[01:06] (66.88s)
hassle whatsoever. For instance, if I
[01:09] (69.12s)
wanted to paste an image, it was as
[01:10] (70.96s)
simple as just pasting it directly into
[01:12] (72.96s)
the interface. And when I needed to add
[01:14] (74.88s)
MCP servers, I could simply navigate to
[01:17] (77.36s)
the settings, go into tool integrations,
[01:19] (79.52s)
and add them right there. Even adding
[01:21] (81.36s)
rules was straightforward, and it came
[01:23] (83.20s)
with this beautiful visual editor where
[01:25] (85.36s)
you could modify your code directly. The
[01:27] (87.68s)
whole experience was just so much more
[01:29] (89.68s)
userfriendly compared to claude code.
[01:31] (91.76s)
But here's where things got interesting.
[01:33] (93.44s)
Cursor eventually released a feature
[01:35] (95.44s)
that let you access Claude code from
[01:37] (97.68s)
within cursor itself. Now, this was
[01:39] (99.68s)
pretty useful because it could bring
[01:41] (101.20s)
your errors from cursor directly into
[01:43] (103.28s)
clawed code. However, it still didn't
[01:45] (105.36s)
give you the full native Claude code
[01:47] (107.28s)
experience. Things like MCPS, rule
[01:49] (109.76s)
files, and creating sub agents still
[01:52] (112.16s)
required you to jump back into the
[01:53] (113.92s)
command line and handle everything
[01:55] (115.68s)
manually. Now, I was willing to work
[01:57] (117.60s)
with most of these limitations, but
[01:59] (119.28s)
there was this one feature that I
[02:00] (120.96s)
absolutely couldn't live without, and
[02:02] (122.64s)
that was the ability to paste images
[02:04] (124.56s)
directly. You see in cursor I can paste
[02:06] (126.88s)
an image and it shows up instantly. But
[02:09] (129.28s)
when I switch over to claude codes
[02:11] (131.04s)
interface and try to do the same thing,
[02:13] (133.04s)
the image simply doesn't appear. I'd
[02:14] (134.96s)
have to provide the actual file path or
[02:17] (137.12s)
go back to the terminal where image
[02:18] (138.96s)
pasting does work. This has honestly
[02:20] (140.88s)
been one of the most frustrating
[02:22] (142.32s)
limitations when using clawed code. But
[02:24] (144.64s)
finally, there's a solution that changes
[02:26] (146.72s)
everything and it's called Claudia. This
[02:29] (149.20s)
brings us to my first reason. Claudia
[02:31] (151.12s)
gives you a complete GUI for Claude code
[02:33] (153.44s)
and it's absolutely incredible. When you
[02:35] (155.52s)
open Claudia, you'll see two distinct
[02:37] (157.44s)
modes, Claude Code agents and Claude
[02:39] (159.68s)
Code projects. Now, Claude Code agents
[02:41] (161.76s)
is where things get really exciting.
[02:43] (163.68s)
This feature transforms the entire GUI
[02:46] (166.16s)
experience. Inside Claude Code agents,
[02:48] (168.48s)
you can create your own custom agents
[02:50] (170.40s)
with remarkable simplicity. These agents
[02:52] (172.80s)
leverage Claude's custom commands,
[02:54] (174.80s)
something we've covered in previous
[02:56] (176.24s)
videos, allowing you to build
[02:57] (177.92s)
specialized AI assistants. The setup
[03:00] (180.32s)
process is intuitive. You name your
[03:02] (182.32s)
agent, choose an icon, select the
[03:04] (184.56s)
default model, and Claudia creates a
[03:06] (186.64s)
completely isolated sandbox for your
[03:08] (188.80s)
project. This means your agent operates
[03:10] (190.80s)
separately from your main working
[03:12] (192.40s)
environment. You control exactly what it
[03:14] (194.64s)
can do, reading files, writing to them,
[03:17] (197.12s)
or searching the internet. The real
[03:18] (198.96s)
power comes from the system prompt,
[03:20] (200.88s)
which defines how your agent behaves.
[03:23] (203.12s)
Let me show you an example. I created a
[03:25] (205.12s)
web search agent specifically for
[03:26] (206.88s)
development tasks. I named it web search
[03:29] (209.20s)
agent. Customized the icon, selected the
[03:31] (211.76s)
model, and disabled write access since
[03:34] (214.08s)
it only needs to read files for context
[03:36] (216.40s)
and search the web. I gave it a focused
[03:38] (218.80s)
system prompt explaining that it
[03:40] (220.56s)
specializes in programming and software
[03:42] (222.72s)
development, prioritizing official
[03:44] (224.72s)
documentation and delivering only
[03:46] (226.64s)
relevant information to keep me
[03:48] (228.32s)
productive. Let me demonstrate how this
[03:50] (230.24s)
works. When I execute the agent, I can
[03:52] (232.48s)
select any project path. In this case,
[03:54] (234.72s)
my notion clone directory. I can choose
[03:56] (236.96s)
the model and enter my task. For
[03:59] (239.04s)
instance, I'll ask it to research the
[04:00] (240.88s)
best Shad CN components for my site.
[04:03] (243.20s)
Watch as it initializes and begins
[04:05] (245.20s)
working on the task. And there we have
[04:07] (247.36s)
it. The exact Shad CN components we
[04:09] (249.76s)
needed, complete with helpful
[04:11] (251.28s)
implementation tips. Oh, and if you're
[04:13] (253.84s)
enjoying the content we're making, I'd
[04:15] (255.76s)
really appreciate it if you hit that
[04:17] (257.36s)
subscribe button. We're also testing out
[04:19] (259.44s)
channel memberships. Launched the first
[04:21] (261.20s)
tier as a test and 82 people have joined
[04:23] (263.84s)
so far. The support's been incredible,
[04:25] (265.76s)
so we're thinking about launching
[04:27] (267.20s)
additional tiers. Right now, members get
[04:29] (269.52s)
priority replies to your comments.
[04:31] (271.44s)
Perfect if you need feedback or have
[04:33] (273.28s)
questions. The second option is Claude
[04:35] (275.60s)
Code projects. And this reveals the
[04:37] (277.52s)
second reason why Claude Code is so much
[04:39] (279.60s)
more powerful. Here you'll find all your
[04:41] (281.68s)
sessions. Every time you initialize
[04:43] (283.60s)
Claude in different folders, they appear
[04:45] (285.60s)
in this organized view. You can
[04:47] (287.36s)
initialize a new Claude code session,
[04:49] (289.44s)
choose your folder, select a model, and
[04:51] (291.68s)
even configure Claude's reasoning level
[04:53] (293.84s)
based on your prompt requirements. Let
[04:55] (295.84s)
me show you a real example. I opened
[04:57] (297.76s)
this project where I asked Claude to
[04:59] (299.76s)
create a mobile app prototype using
[05:01] (301.84s)
HTML, specifically an Uber app prototype
[05:04] (304.80s)
with custom theme requirements. Claude
[05:06] (306.88s)
responded exactly as it normally does,
[05:09] (309.20s)
starting with a to-do list. But now that
[05:11] (311.04s)
to-do list appears in this beautiful GUI
[05:13] (313.52s)
format. You can watch as it works
[05:15] (315.28s)
through each task systematically, then
[05:17] (317.52s)
moves on to writing the actual files,
[05:19] (319.60s)
completing every item on the list. The
[05:21] (321.52s)
result, a complete app prototype from a
[05:23] (323.68s)
single prompt. The UI is solid and with
[05:25] (325.84s)
better prompting, it could be even more
[05:27] (327.68s)
impressive. But what matters is that
[05:29] (329.52s)
this entire process now happens within
[05:31] (331.68s)
an intuitive visual interface. To
[05:34] (334.48s)
demonstrate the second reason, I built
[05:36] (336.32s)
this Nex.js app. I told Claude to create
[05:38] (338.64s)
a Next.js JS app and build a notion
[05:40] (340.56s)
landing page clone inside it. It created
[05:42] (342.80s)
its own to-do list and followed it step
[05:44] (344.88s)
by step, writing to files, checking
[05:46] (346.80s)
them, and notifying me when complete.
[05:48] (348.80s)
Another incredible feature of this new
[05:50] (350.64s)
GUI is the built-in preview window. You
[05:53] (353.20s)
can paste your URL and it opens your
[05:55] (355.20s)
site directly within the interface.
[05:57] (357.20s)
Remember that image issue I had when
[05:58] (358.96s)
using clawed code inside cursor? That's
[06:01] (361.44s)
completely solved here. It automatically
[06:03] (363.52s)
captures any issues you're experiencing.
[06:05] (365.68s)
You can see it caught this contrast
[06:07] (367.36s)
problem and lets you paste images
[06:09] (369.20s)
directly without manual file paths. Just
[06:11] (371.68s)
enter your prompt below and you're good
[06:13] (373.44s)
to go. Now, I'll be honest, there are a
[06:15] (375.60s)
few UI issues since the project is still
[06:17] (377.76s)
in development. It's already usable, but
[06:19] (379.92s)
there are some small bugs that will be
[06:21] (381.68s)
resolved soon. I'm telling it to fix the
[06:23] (383.68s)
contrast issue, and it's handling that.
[06:25] (385.76s)
But the real second reason why this GUI
[06:28] (388.08s)
is so much more powerful is checkpoints.
[06:30] (390.40s)
When working with Cursor, you get
[06:32] (392.08s)
checkpoints for every prompt you send,
[06:34] (394.24s)
allowing you to restore previous states
[06:36] (396.24s)
if anything goes wrong. This is one of
[06:38] (398.16s)
Cursor's most powerful features. You
[06:40] (400.24s)
don't worry about Git commits since not
[06:42] (402.24s)
every developer wants to deal with Git.
[06:44] (404.24s)
Having this built-in gives you complete
[06:46] (406.16s)
assurance that whatever the AI does is
[06:48] (408.40s)
reversible. This new tool brings that
[06:50] (410.64s)
same power with its timeline feature and
[06:52] (412.88s)
checkpoint system. I created a
[06:54] (414.56s)
checkpoint before making this change. So
[06:56] (416.56s)
if it doesn't fix correctly, I can
[06:58] (418.40s)
instantly return to my original state.
[07:00] (420.64s)
That's the power of this new GUI. You
[07:03] (423.04s)
also get a usage dashboard showing your
[07:05] (425.20s)
consumption plus a claw.md file so you
[07:08] (428.08s)
don't have to manually edit things in
[07:09] (429.76s)
terminal. One of the most powerful
[07:11] (431.28s)
features is adding MCP servers directly
[07:13] (433.68s)
from the interface. No more JSON files,
[07:16] (436.00s)
no more wrapping everything in single
[07:17] (437.68s)
quotes and typing manually in terminal.
[07:19] (439.68s)
Just copy paste the values, add your
[07:21] (441.60s)
arguments and commands for SSC servers.
[07:24] (444.32s)
Paste the URL and your MCP server is
[07:26] (446.88s)
ready to use. Using MCP servers with
[07:29] (449.36s)
cloud code has never been easier. And
[07:31] (451.44s)
this tool makes Claude code accessible
[07:33] (453.36s)
to developers who don't want to live in
[07:35] (455.20s)
the terminal. For me, this is a complete
[07:37] (457.36s)
gamecher. Now you might be thinking, is
[07:40] (460.16s)
it easy to install? Well, it requires a
[07:42] (462.80s)
few steps. It's available for all
[07:44] (464.72s)
platforms, Mac, Windows, and Linux. But
[07:47] (467.44s)
currently you need to install it from
[07:49] (469.28s)
source. That means building the app
[07:51] (471.28s)
yourself using the provided code and
[07:53] (473.52s)
instructions. Don't worry though, the
[07:55] (475.44s)
process is straightforward if you follow
[07:57] (477.20s)
along. In the GitHub repository, scroll
[07:59] (479.60s)
down to see the prerequisites. You'll
[08:01] (481.44s)
need Rust installed, bun installed, and
[08:03] (483.76s)
Git, which comes pre-installed on Mac
[08:05] (485.84s)
and Linux, but Windows users may need to
[08:08] (488.08s)
install it separately. Since this runs
[08:10] (490.08s)
on top of cloud code, you'll need that
[08:12] (492.08s)
installed as well. Once you have all
[08:13] (493.92s)
prerequisites ready, copy this command
[08:16] (496.16s)
and paste it into your terminal. This
[08:18] (498.16s)
clones the repository and moves you into
[08:20] (500.32s)
the directory. Next, run bun install
[08:23] (503.04s)
followed by the build command. You have
[08:24] (504.72s)
two options here. Development build,
[08:26] (506.88s)
useful if you want to modify the open-
[08:29] (509.04s)
source code and view changes in your
[08:30] (510.88s)
browser or production build, which
[08:32] (512.80s)
creates a readytouse application. Follow
[08:35] (515.12s)
these commands in sequence and the app
[08:37] (517.12s)
will appear as an icon in your
[08:38] (518.88s)
applications folder ready to launch.
[08:41] (521.36s)
That brings us to the end of this video.
[08:43] (523.20s)
If you'd like to support the channel and
[08:44] (524.88s)
help us keep making videos like this,
[08:46] (526.88s)
you can do so by using the super thanks
[08:48] (528.88s)
button below. As always, thank you for
[08:50] (530.80s)
watching and I'll see you in the next