[00:00] (0.16s)
Do you want to see something cool? Just
[00:01] (1.84s)
look at this. I'm in my terminal and I
[00:03] (3.60s)
typed out this command. Now watch what
[00:05] (5.36s)
happens. It fires up this tool called
[00:07] (7.20s)
Claude Squad. By the name, you can
[00:08] (8.96s)
probably guess what it does. It
[00:10] (10.40s)
generates multiple versions of Claude
[00:12] (12.24s)
code in a single terminal. You can
[00:13] (13.76s)
assign different tasks to each instance,
[00:15] (15.76s)
and it's honestly pretty amazing. Next,
[00:17] (17.84s)
let me show you how to use it. The guide
[00:19] (19.44s)
is pretty clear. You just press N to
[00:21] (21.68s)
open a new instance of clawed code.
[00:23] (23.76s)
Let's say this one will work on the
[00:25] (25.28s)
front end. So, I've named this the
[00:27] (27.12s)
front-end session. Then let's go ahead
[00:29] (29.12s)
and create another one. Again, I'm
[00:30] (30.80s)
pressing N and this one is going to
[00:32] (32.48s)
handle the back end. Now I have another
[00:34] (34.32s)
instance where the clawed code agent is
[00:36] (36.48s)
focused on back-end tasks. This tool is
[00:38] (38.80s)
honestly amazing. I recently stumbled
[00:40] (40.72s)
upon it while scrolling through X. So
[00:42] (42.72s)
now let me show you how it works, the
[00:44] (44.72s)
kind of cool stuff you can do with it,
[00:46] (46.24s)
and how Claude Code and Cursor are now
[00:48] (48.40s)
working together. If you like the
[00:50] (50.32s)
content we're making, I'd really
[00:52] (52.24s)
appreciate it if you could subscribe.
[00:54] (54.00s)
Right now, we're also testing out
[00:55] (55.76s)
memberships to support the channel.
[00:57] (57.36s)
We've only launched the first tier and
[00:59] (59.20s)
for now it offers priority comment
[01:01] (61.44s)
replies, but subscribing helps us see
[01:03] (63.60s)
how many of you are interested and want
[01:05] (65.36s)
to support what we're doing. Claude Code
[01:07] (67.52s)
has done something wild. They've
[01:09] (69.04s)
integrated Claude Code directly into
[01:11] (71.12s)
your IDE. The feature is called IDE
[01:13] (73.44s)
integration and it lets you use Claude
[01:15] (75.52s)
Code inside your IDE. Don't just get
[01:17] (77.68s)
excited that Claude Code is now
[01:19] (79.44s)
available in your IDE. Focus on the
[01:21] (81.60s)
facts. What does it offer and what are
[01:23] (83.60s)
the real benefits? Normally, if you open
[01:25] (85.76s)
the same project directory in both
[01:27] (87.52s)
Claude Code and Cursor, they're already
[01:29] (89.52s)
working on the same code. But this
[01:31] (91.12s)
integration adds extra features on top
[01:33] (93.44s)
of that. First, the obvious one. You can
[01:35] (95.84s)
now use Claude code directly inside
[01:38] (98.16s)
cursor. Here's something I found really
[01:40] (100.08s)
useful in this mode, selection context.
[01:42] (102.72s)
Whenever you highlight something in the
[01:44] (104.40s)
code, it's automatically shared with
[01:46] (106.24s)
cursor. If you copy something, cursor's
[01:48] (108.56s)
agent already has it. No need to paste
[01:50] (110.56s)
it manually. Same thing happens here,
[01:52] (112.48s)
too. You just select something in the
[01:54] (114.16s)
IDE and it's automatically shared with
[01:56] (116.32s)
clawed code which is honestly a solid
[01:58] (118.24s)
feature. Another thing that made cursor
[02:00] (120.16s)
really powerful is how it automatically
[02:02] (122.24s)
shared small errors like lint errors and
[02:04] (124.72s)
syntax errors with the agent. I'm not
[02:06] (126.88s)
sure about console errors yet, but lint
[02:09] (129.04s)
and syntax errors are already covered.
[02:11] (131.36s)
Claude code is now going to do the same
[02:13] (133.28s)
thing. Next, a quick recap in case you
[02:15] (135.84s)
don't know how this works. Here's the
[02:17] (137.52s)
process. First, install claude code.
[02:19] (139.76s)
Just copy the command, paste it, and
[02:21] (141.68s)
it'll install in your terminal. If
[02:23] (143.44s)
you're having trouble or don't want to
[02:24] (144.96s)
use the terminal, copy the command, open
[02:27] (147.28s)
cursor, and ask it to do it for you.
[02:29] (149.36s)
It's really not difficult anymore.
[02:30] (150.96s)
Inside cursor, open your integrated
[02:33] (153.12s)
terminal. That's the one built into
[02:34] (154.80s)
cursor. The first time you do this,
[02:36] (156.56s)
it'll install an extension called Claude
[02:38] (158.72s)
Code. Let me show you. This is what gets
[02:40] (160.56s)
installed when you connect the first
[02:42] (162.00s)
time. After that, if you want to run it
[02:43] (163.92s)
inside Cursor, open the command pallet,
[02:46] (166.32s)
search for run clawed code, and hit
[02:48] (168.32s)
enter. It'll open the claude code
[02:50] (170.08s)
terminal in a new window right inside
[02:51] (171.92s)
cursor. You can close the old terminal
[02:53] (173.92s)
if you want. Now you've got the claw
[02:55] (175.68s)
code terminal embedded inside cursor and
[02:58] (178.00s)
it supports all the commands we've
[02:59] (179.68s)
talked about. Now here's a major
[03:01] (181.04s)
benefit. Claude code doesn't limit your
[03:02] (182.96s)
base model's context. Right now I'm
[03:04] (184.88s)
using claw force on it. If I use the
[03:06] (186.88s)
same model in cursor, cursor limits the
[03:09] (189.04s)
context per model usually to save API
[03:11] (191.44s)
costs. But this is the raw model so you
[03:13] (193.68s)
get way more context. That alone is a
[03:15] (195.84s)
huge advantage. And Claude also manages
[03:17] (197.92s)
context extremely well. Let me show you
[03:19] (199.76s)
something. I'll type a prompt. Make a
[03:21] (201.44s)
website in HTML, CSS, and JS for a
[03:24] (204.32s)
fishing business. When I press enter,
[03:26] (206.00s)
you'll see it generates to-dos, which is
[03:27] (207.92s)
incredibly useful. You might remember
[03:29] (209.68s)
our channel has showcased a bunch of
[03:31] (211.68s)
videos using cursor in a structured way.
[03:34] (214.16s)
Claude Code does that by default, and
[03:36] (216.24s)
that's one of the biggest reasons to use
[03:37] (217.92s)
this tool. Even if you don't like
[03:39] (219.52s)
working in the terminal, maybe you
[03:41] (221.12s)
prefer an IDE, because let's be honest,
[03:43] (223.28s)
the terminal can scare a lot of Vibe
[03:45] (225.12s)
coders. This setup makes it really easy
[03:47] (227.20s)
for them to still use clawed code. Also,
[03:49] (229.68s)
one more thing, it shows you how many
[03:51] (231.44s)
tokens are being used in real time as
[03:53] (233.36s)
you work. That's pretty helpful, too.
[03:55] (235.44s)
About the tool claqued in the beginning,
[03:58] (238.08s)
I tried using the same method with that
[03:59] (239.76s)
tool. So, let me show you. I've just
[04:01] (241.44s)
initialized Claude Squad here. And now,
[04:03] (243.44s)
let me open up this session. This is the
[04:05] (245.36s)
command for checking the IDE connection.
[04:07] (247.68s)
You can also see the other commands.
[04:09] (249.36s)
These are the commands for Claude code.
[04:11] (251.36s)
I've opened a Claude code instance using
[04:13] (253.44s)
this through Claude Squad. As you know,
[04:15] (255.20s)
Claude Squad allows you to run multiple
[04:17] (257.28s)
instances of Claude code. When I run
[04:19] (259.12s)
this command, it says no available idees
[04:21] (261.84s)
have been detected. So, clearly, there's
[04:23] (263.92s)
some issue. It's not able to detect the
[04:26] (266.16s)
IDE. Honestly, this only blocks us from
[04:28] (268.56s)
accessing a few features I mentioned
[04:30] (270.40s)
earlier, and they're not super critical.
[04:32] (272.32s)
The multi- aent capability that Claude
[04:34] (274.48s)
Squad offers is way cooler. If you know
[04:36] (276.80s)
how to work with these agents together,
[04:38] (278.88s)
it becomes much more useful, way faster,
[04:41] (281.44s)
and just a lot more powerful. Here's a
[04:43] (283.76s)
classic example of how to use multiple
[04:45] (285.92s)
instances of these cla code terminals.
[04:48] (288.32s)
If you go on X and search multiple
[04:50] (290.40s)
claude code, people have been doing some
[04:52] (292.32s)
crazy amazing things with it. Let me
[04:54] (294.24s)
give you a simple example that came to
[04:56] (296.08s)
my mind. So you have a front end and
[04:57] (297.84s)
backend app. They're connected by APIs.
[05:00] (300.64s)
API blueprints can be created to define
[05:03] (303.04s)
exactly what needs to be built and then
[05:04] (304.96s)
the front end and back end are
[05:06] (306.40s)
structured around those APIs. That's
[05:08] (308.48s)
exactly what I asked one of the
[05:09] (309.84s)
instances to do. I gave it the spec and
[05:12] (312.08s)
told it to start creating the front end
[05:13] (313.92s)
based on that. And if I check this now,
[05:16] (316.00s)
you can see it's still working. Now I go
[05:17] (317.76s)
into the next session. And if I open it,
[05:19] (319.84s)
I can prompt it to do something else.
[05:21] (321.60s)
This is just crazy. It really shows how
[05:23] (323.68s)
amazing this tool is. I stumbled across
[05:25] (325.84s)
it and thought I'd share it with you.
[05:27] (327.52s)
These tools are coming together in a way
[05:29] (329.44s)
where you can mix and match having
[05:31] (331.36s)
multiple agents working on different
[05:33] (333.12s)
parts of a project. Sure, it's going to
[05:34] (334.96s)
take a lot of planning to build a
[05:36] (336.40s)
full-scale production ready app, but if
[05:38] (338.48s)
you use all of them smartly, it'll be
[05:40] (340.48s)
way faster. The trade-off is that it's
[05:42] (342.64s)
going to be a lot more expensive. That
[05:44] (344.40s)
brings me to something Claude recently
[05:46] (346.00s)
introduced. It's called the Max Plan. It
[05:48] (348.24s)
costs $100 per month, and what it gives
[05:50] (350.80s)
you is a much more generous usage limit.
[05:53] (353.36s)
Basically, an unlimited token cap that
[05:55] (355.92s)
resets every 5 hours. It's not like the
[05:58] (358.48s)
older pro plan where you had a monthly
[06:00] (360.48s)
quota. And of course, the free plan
[06:02] (362.24s)
doesn't offer any serious token
[06:03] (363.92s)
allowance. But with the max plan, if you
[06:06] (366.16s)
connect it to Claude code, you get
[06:07] (367.92s)
unlimited tokens with some of the
[06:09] (369.60s)
models. Even with the best model, Claude
[06:11] (371.60s)
Opus, they've implemented an hourly rate
[06:13] (373.84s)
limit instead of monthly limits, which
[06:15] (375.68s)
is a lot better overall. It also works
[06:17] (377.68s)
with OpenAI codeex, which is another
[06:19] (379.68s)
Claude code style coding agent that runs
[06:21] (381.92s)
directly in your terminal. If you like
[06:23] (383.92s)
this tool and want to install it, let me
[06:25] (385.84s)
show you how. Installing it really isn't
[06:27] (387.84s)
that difficult. on their main website
[06:29] (389.68s)
and I'll leave the link in the
[06:31] (391.04s)
description below. Just head over and
[06:32] (392.96s)
visit their GitHub. All the install
[06:34] (394.88s)
instructions I'm about to walk you
[06:36] (396.40s)
through are listed there so you can copy
[06:38] (398.48s)
them directly. The first things you need
[06:40] (400.16s)
to have on your system are two tools,
[06:42] (402.24s)
T-Max and GH. You need to have both
[06:44] (404.56s)
installed. Right now, T-Mox is only
[06:46] (406.80s)
available for Mac OS and various Linux
[06:49] (409.20s)
distributions. So, unfortunately, this
[06:51] (411.28s)
won't work on Windows. Let's hope the
[06:53] (413.04s)
developers gain enough traction to
[06:54] (414.72s)
release a compatible version for Windows
[06:56] (416.64s)
as well. The commands to install T-Max
[06:58] (418.96s)
are listed right there. If you go into
[07:00] (420.72s)
the GH directory, you'll find the
[07:02] (422.64s)
command to install the GitHub CLI too.
[07:05] (425.20s)
After that, they provide an automated
[07:07] (427.28s)
installation script. Just copy it. It's
[07:09] (429.52s)
right there and paste it into your
[07:11] (431.28s)
terminal to run that will install the
[07:13] (433.20s)
entire tool for you. Once it's
[07:14] (434.72s)
installed, you can initialize it using
[07:16] (436.72s)
the command CS, which stands for Claude
[07:19] (439.04s)
Squad. As you can see, it's been
[07:20] (440.48s)
initialized here. This is a session I
[07:22] (442.48s)
created and it's now active. But you
[07:24] (444.56s)
can't initialize this tool in just any
[07:26] (446.96s)
directory. To use it, you need to be in
[07:29] (449.04s)
a folder where GitHub is already
[07:31] (451.20s)
properly set up. So if you have an older
[07:33] (453.44s)
project that you now want to integrate
[07:35] (455.36s)
Claude Squad into with multiple agents
[07:37] (457.76s)
working on different tasks and Git is
[07:39] (459.92s)
already initialized, then you're good to
[07:41] (461.68s)
go. If not, you'll need to run a few
[07:43] (463.76s)
commands to set that up. Use these
[07:45] (465.60s)
commands to initialize a GitHub
[07:47] (467.44s)
repository and make your first commit so
[07:49] (469.84s)
the tool can detect your working tree.
[07:51] (471.84s)
The working tree is the folder where you
[07:53] (473.92s)
make code changes and as you create
[07:55] (475.84s)
different versions of your codebase,
[07:57] (477.76s)
those changes get tracked. Claude Squad
[08:00] (480.08s)
and the Claude powered code without a
[08:02] (482.00s)
Git repository initialized, it won't
[08:04] (484.16s)
function. And for those of you
[08:05] (485.60s)
unfamiliar with using the terminal, if
[08:07] (487.84s)
you already have a project, just paste
[08:09] (489.84s)
the commands. If you're starting from
[08:11] (491.60s)
scratch in an empty folder, you'll need
[08:13] (493.68s)
to create a simple file to make your
[08:15] (495.76s)
first commit. You can use this command.
[08:17] (497.76s)
It creates a file called ignore.txt,
[08:19] (499.92s)
txt, which is just a placeholder. Then
[08:22] (502.40s)
initialize your GitHub repository using
[08:24] (504.80s)
the earlier command. And finally, use
[08:26] (506.80s)
the Claude Squad command to launch the
[08:28] (508.72s)
tool. And there you have it. That brings
[08:30] (510.72s)
us to the end of this video. If you'd
[08:32] (512.40s)
like to support the channel and help us
[08:34] (514.24s)
keep making tutorials like this, you can
[08:36] (516.24s)
do so by using the super thanks button
[08:38] (518.32s)
below. As always, thank you for watching
[08:40] (520.24s)
and I'll see you in the next one.