[00:00] (0.16s)
Claude Code is different. It's a truly
[00:02] (2.08s)
unique coding agent that is actually
[00:04] (4.00s)
programmable. And this is what makes it
[00:05] (5.84s)
so powerful. What makes Claude Code
[00:07] (7.84s)
unique isn't just that it's an AI coding
[00:10] (10.08s)
assistant, but that it's built to be
[00:11] (11.84s)
fundamentally customizable at its core.
[00:14] (14.24s)
This programmable architecture means
[00:16] (16.16s)
Claude Code can adapt to any workflow
[00:18] (18.64s)
and execute tasks in ways that are
[00:20] (20.88s)
completely tailored to your specific
[00:22] (22.72s)
needs. The level of programmability it
[00:24] (24.88s)
offers is something you simply can't
[00:26] (26.64s)
find anywhere else, not even in tools
[00:28] (28.72s)
like Cursor. Because of how Claude Code
[00:30] (30.56s)
is designed, people have been able to
[00:32] (32.32s)
customize it in ways that are truly
[00:34] (34.32s)
remarkable. To really show you how
[00:36] (36.08s)
powerful Claude Code has become, let me
[00:38] (38.00s)
show you some of the ways it has been
[00:39] (39.60s)
implemented. The Claude Code SDK is what
[00:42] (42.40s)
essentially makes it a programmable
[00:44] (44.00s)
agent. This has completely changed how
[00:46] (46.08s)
we view and work with AI agents. Someone
[00:48] (48.56s)
had an incredible idea and actually went
[00:50] (50.80s)
ahead and turned Claude Code into a
[00:52] (52.80s)
fully working MCP. This is a real
[00:54] (54.96s)
functional MCP and it's absolutely
[00:57] (57.20s)
remarkable. I never imagined someone
[00:59] (59.20s)
would build Claude code as an MCP. Let
[01:01] (61.68s)
me show you an example. If I close this
[01:03] (63.52s)
and open it back up, you can see the
[01:05] (65.28s)
taxi app prototype is here. Let's ask
[01:07] (67.52s)
the Claude MCP to edit the taxi app file
[01:10] (70.48s)
and change the main color from yellow to
[01:12] (72.48s)
blue. When I send this request, you'll
[01:14] (74.40s)
see it's calling Claude code as an MCP
[01:16] (76.80s)
server. It receives the prompt to change
[01:18] (78.80s)
the color along with additional
[01:20] (80.40s)
instructions as well. Okay, so I had
[01:22] (82.32s)
been working on this for a while and it
[01:24] (84.16s)
actually already changed the color when
[01:25] (85.76s)
I tested it earlier. But let me show it
[01:27] (87.68s)
to you as well. You can see that as I
[01:29] (89.52s)
refreshed it, it changed the colors. Now
[01:31] (91.68s)
let's try asking it to make some
[01:33] (93.36s)
additional changes again. You'll see
[01:35] (95.04s)
it's calling claude code. As a result,
[01:37] (97.28s)
we get the prompt back from claude code
[01:39] (99.36s)
inside cursor. We're now working with
[01:41] (101.36s)
what claude code returned. If you look
[01:43] (103.28s)
at it now, it actually resembles a
[01:45] (105.28s)
material interface instead of the neon
[01:47] (107.44s)
theme we had before. I can see two main
[01:49] (109.68s)
use cases here. Even though it's an
[01:51] (111.60s)
unconventional idea, there have been
[01:53] (113.28s)
many scenarios, especially when building
[01:55] (115.44s)
UI where I've tried to implement
[01:57] (117.28s)
something and cursor simply couldn't
[01:59] (119.12s)
handle it. This happens because its
[02:00] (120.80s)
models are limited by their context
[02:02] (122.56s)
window. The same model claude has
[02:04] (124.24s)
different context limits depending on
[02:05] (125.92s)
the version. For example, claude 3 here
[02:08] (128.00s)
has a 120k token limit while cla code
[02:11] (131.20s)
has its full context limit of around
[02:13] (133.20s)
200k tokens. That makes a significant
[02:15] (135.52s)
difference. Whenever cursor can't handle
[02:17] (137.60s)
something, you can call out to clawed
[02:19] (139.36s)
code and it will solve that problem for
[02:21] (141.20s)
you. And if you're saying that you can
[02:22] (142.80s)
use the clawed code IDE feature, that's
[02:24] (144.88s)
okay. But cursor won't know what it
[02:26] (146.80s)
changed and the context mismatch isn't a
[02:28] (148.96s)
good thing. Using this approach, cursor
[02:30] (150.88s)
maintains the context of changes
[02:32] (152.64s)
claimless
[02:35] (155.04s)
workflow between both tools. The second
[02:37] (157.12s)
use case involves the claude desktop app
[02:39] (159.44s)
which I myself use frequently. I really
[02:41] (161.76s)
enjoy brainstorming in it and the canvas
[02:43] (163.84s)
feature is excellent. For example, when
[02:45] (165.92s)
you build something like a component,
[02:47] (167.92s)
you can take elements from the claude
[02:49] (169.68s)
desktop app and ask it in the prompt to
[02:52] (172.08s)
implement them. Claude code will take
[02:53] (173.92s)
whatever you've built there and
[02:55] (175.28s)
implement it here. For instance, it just
[02:57] (177.04s)
generated this beautiful component for
[02:58] (178.96s)
me. Now, I can ask Claude MCP right here
[03:01] (181.28s)
to implement it and Claude Desktop will
[03:03] (183.36s)
provide full context so it can easily
[03:05] (185.44s)
handle that task. Oh, and if you're
[03:07] (187.52s)
enjoying the content, please hit that
[03:09] (189.36s)
subscribe button. We've also launched
[03:11] (191.20s)
channel memberships. 97 people have
[03:13] (193.60s)
already joined our first tier. Members
[03:15] (195.52s)
get priority replies to comments. So if
[03:17] (197.92s)
you need feedback or have questions,
[03:19] (199.68s)
that's the best way to reach us. We all
[03:21] (201.76s)
know that Claude Code is the best agent
[03:23] (203.60s)
out there. But what if you want to use a
[03:25] (205.84s)
different model with the best agent
[03:27] (207.60s)
architecture available? For example, if
[03:29] (209.84s)
you want to use different models like
[03:31] (211.52s)
Gemini or the new Kimmy K2, which
[03:34] (214.00s)
delivers claude code level performance
[03:35] (215.92s)
at a fraction of the cost, then here's
[03:37] (217.84s)
exactly what you can do. I discovered
[03:39] (219.84s)
this tool called Claude Code Router and
[03:42] (222.16s)
it does exactly what you think it does.
[03:44] (224.24s)
This tool allows you to use multiple
[03:46] (226.32s)
models from different providers. You can
[03:48] (228.56s)
access Gemini, OpenAI models or even the
[03:51] (231.52s)
Kim K2 model. This is genuinely
[03:54] (234.00s)
impressive. When you scroll down, you'll
[03:55] (235.92s)
see the built-in providers they support.
[03:57] (237.92s)
Deepseek, Gemini, and Open Router. I'll
[04:00] (240.56s)
be using Open Router to access the Kimmy
[04:02] (242.72s)
K2 model, and this requires the Open
[04:04] (244.88s)
Router API. The installation process is
[04:07] (247.20s)
straightforward. First, make sure you
[04:08] (248.96s)
have Claude Code installed. Then, copy
[04:10] (250.96s)
the provided command, paste it into your
[04:12] (252.96s)
terminal, and it will install the tool
[04:14] (254.80s)
globally. Next, you'll need to modify
[04:16] (256.88s)
this config.json file. You will have to
[04:19] (259.36s)
create this manually in your files. Or
[04:21] (261.44s)
you can use this command that I used,
[04:23] (263.20s)
which creates the folder automatically.
[04:25] (265.28s)
Navigate to the folder and open it in
[04:27] (267.28s)
cursor. When you first open it, the file
[04:29] (269.52s)
will be empty. To fill it out, they
[04:31] (271.44s)
provide an example file with all the
[04:33] (273.60s)
necessary fields. When you open the
[04:35] (275.52s)
example, you'll see all the different
[04:37] (277.36s)
providers listed with complete
[04:39] (279.04s)
configurations. Simply copy the sections
[04:41] (281.44s)
you need. In my setup, I kept only the
[04:43] (283.68s)
open router block and remove the other
[04:45] (285.84s)
configurations. However, there are two
[04:48] (288.08s)
essential blocks. You must keep the
[04:49] (289.76s)
router block and the block containing
[04:51] (291.60s)
your API key and host address. Here's
[04:53] (293.92s)
what you need to modify. Paste your open
[04:55] (295.84s)
router API key. Then add the model name.
[04:58] (298.32s)
This is the KIK2 model name. And
[05:00] (300.40s)
whatever one you use, make sure that you
[05:02] (302.16s)
paste the correct full name. I got mine
[05:04] (304.24s)
from open router here. In the router
[05:06] (306.16s)
section as well, include the provider
[05:08] (308.32s)
name followed by the full model name.
[05:10] (310.40s)
Once your configuration is complete,
[05:12] (312.40s)
navigate to your desired directory where
[05:14] (314.64s)
you want to start this modified cloud
[05:16] (316.72s)
code and type CCR code to launch. The
[05:19] (319.52s)
system will pick up your API keys and
[05:21] (321.60s)
you can see this message about
[05:23] (323.04s)
overridden settings. This confirms it's
[05:25] (325.20s)
now using Kimmy K2 as the model. You may
[05:27] (327.68s)
encounter this error. This typically
[05:29] (329.52s)
happens when using both pro account and
[05:31] (331.68s)
API simultaneously causing conflicts.
[05:34] (334.32s)
I've checked, but the system will still
[05:36] (336.08s)
function with the Kimik2 model because
[05:38] (338.32s)
the first time you initialize using the
[05:40] (340.32s)
CCR command, you'll see a menu asking
[05:42] (342.72s)
about the custom API key. Don't click
[05:44] (344.96s)
no. Select yes to proceed with your
[05:47] (347.28s)
chosen key. Let me demonstrate with a
[05:49] (349.20s)
simple prompt. I've asked it to create
[05:50] (350.88s)
the taxi app prototype that you saw in
[05:53] (353.20s)
the start of the video. As you can see,
[05:54] (354.88s)
it's processing the request. You'll
[05:56] (356.64s)
notice the response is slower than
[05:58] (358.24s)
usual. This is typical for the Kim K2
[06:00] (360.56s)
model, but considering the significant
[06:02] (362.40s)
cost savings and the same performance
[06:04] (364.16s)
level, it's an excellent trade-off.
[06:05] (365.84s)
You've already seen it, but again, this
[06:07] (367.84s)
is the result that it gave us. The
[06:09] (369.68s)
really exciting part about this is that
[06:11] (371.60s)
you now have access to the world's best
[06:13] (373.76s)
coding agent with complete control over
[06:16] (376.08s)
which models you use. So, this is Claude
[06:19] (379.12s)
Flow, a project by someone who's
[06:21] (381.04s)
contributed many amazing things over the
[06:23] (383.28s)
years. As I was reading through this, I
[06:25] (385.28s)
discovered it allows Claude to spawn
[06:27] (387.36s)
multiple instances of itself to run a
[06:29] (389.76s)
single task so that it gets completed
[06:31] (391.92s)
even faster. For example, give it a task
[06:34] (394.40s)
to implement a REST API and Claude Flow
[06:37] (397.12s)
will divide the task across those
[06:38] (398.88s)
instances and complete it as quickly as
[06:41] (401.20s)
possible. It's all about having multiple
[06:43] (403.12s)
agents completing tasks efficiently.
[06:45] (405.44s)
Initially, I thought this wasn't really
[06:47] (407.44s)
useful because a multi- aent system is
[06:49] (409.76s)
also implemented in Claude Code's own
[06:51] (411.84s)
system where it spawns multiple agents
[06:54] (414.16s)
for separate tasks. But then I came
[06:56] (416.08s)
across the Hivemind feature. And this is
[06:58] (418.00s)
where it gets really interesting. To use
[06:59] (419.68s)
it, you need to have Claude Flow set up
[07:01] (421.68s)
first. The reason I bring this up is
[07:03] (423.52s)
because for this to work properly, you
[07:05] (425.44s)
have to use a command that puts it into
[07:07] (427.36s)
bypass mode. That isn't ideal because
[07:09] (429.68s)
you never know what Claude Flow might do
[07:11] (431.52s)
in that mode. it could move outside your
[07:13] (433.60s)
specified repository or even delete
[07:15] (435.76s)
files on your system. So there is some
[07:17] (437.68s)
level of caution required here. The
[07:19] (439.52s)
author actually recommends using GitHub
[07:21] (441.68s)
code spaces which is a slightly more
[07:23] (443.52s)
complex topic. But coming back to
[07:25] (445.20s)
Hivemind, let me give you an example of
[07:27] (447.28s)
what I mean. When you want to start it
[07:28] (448.96s)
up, you initialize it with this command,
[07:31] (451.12s)
the initial command. If you want to
[07:32] (452.80s)
initialize it with a specific project
[07:34] (454.88s)
name, you can do that too, just like
[07:36] (456.88s)
they've shown here. Each swarm or hive
[07:39] (459.68s)
that the author describes is responsible
[07:42] (462.00s)
for a specific feature of your app. So
[07:44] (464.16s)
if you're building an O system, you
[07:46] (466.00s)
assign that to a swarm or hive and
[07:48] (468.32s)
implement it systematically. Where
[07:50] (470.00s)
Hivemind really shines is in its
[07:52] (472.00s)
architecture. There's a queen-led
[07:53] (473.76s)
infrastructure where a queen agent gives
[07:56] (476.00s)
instructions to the others and all
[07:57] (477.84s)
agents operate under the same context.
[08:00] (480.08s)
Memory management is handled
[08:01] (481.68s)
exceptionally well. Right here you can
[08:03] (483.60s)
see this full file system laid out.
[08:05] (485.60s)
Everything has been managed from memory
[08:07] (487.44s)
to coordination. The amazing part about
[08:09] (489.60s)
this Hivemind is that since these are
[08:11] (491.76s)
sessions, you get a session ID when you
[08:14] (494.08s)
create one. You can resume that session
[08:16] (496.16s)
ID later, which means you can keep
[08:18] (498.08s)
working on that same feature without
[08:20] (500.08s)
starting over. So your multi- aent
[08:22] (502.08s)
system can remain preserved and you can
[08:24] (504.00s)
start off from it wherever you like. One
[08:25] (505.92s)
area where I felt it was lacking,
[08:28] (508.00s)
especially for full project builds, is
[08:30] (510.00s)
that there was no clear starting point
[08:31] (511.92s)
or workflow. I could run the swarm for a
[08:34] (514.40s)
single feature as I showed you. But
[08:36] (516.16s)
there wasn't a proper built-in flow to
[08:38] (518.08s)
guide the process. I think that's mainly
[08:40] (520.08s)
because it's still in development and
[08:41] (521.84s)
not fully complete yet. But once it is
[08:43] (523.92s)
and once a clear workflow is
[08:45] (525.60s)
implemented, I'll definitely be doing a
[08:47] (527.52s)
dedicated video on this because it's
[08:49] (529.28s)
genuinely something worth exploring.
[08:51] (531.44s)
There's also an amazing repository
[08:53] (533.04s)
called Awesome Claude Code. It's a
[08:54] (534.80s)
curated list of command files,
[08:56] (536.64s)
workflows, and tools for Claude Code. It
[08:58] (538.88s)
has everything you need. community
[09:00] (540.48s)
workflows, useful tools for cloud code,
[09:02] (542.88s)
and many resources we've featured in
[09:04] (544.80s)
previous videos. You'll also find Claude
[09:07] (547.04s)
Code hooks and custom/comands. It's a
[09:09] (549.68s)
really great resource, and I'll leave it
[09:11] (551.44s)
linked below. Similar to the Claude Code
[09:13] (553.60s)
customizations I showed earlier, this
[09:15] (555.68s)
offers many more options to explore.
[09:17] (557.84s)
It's incredibly useful. Browse through
[09:19] (559.84s)
it, find what interests you, and try it
[09:22] (562.24s)
out to see if it works for your
[09:23] (563.76s)
workflow. You probably already know that
[09:25] (565.92s)
Claude Code can be used inside Cursor
[09:28] (568.24s)
and other IDEs. When you type claude, it
[09:30] (570.96s)
initializes and provides you with a side
[09:33] (573.12s)
panel where you can use claude code and
[09:35] (575.28s)
it can access errors from cursor. It
[09:37] (577.68s)
functions like a chat version of claude
[09:39] (579.60s)
code, but I've never really liked this
[09:41] (581.36s)
chat menu and don't like the experience
[09:43] (583.36s)
that it gives. However, I recently
[09:45] (585.20s)
discovered something exceptional called
[09:47] (587.04s)
claude code chat. It's essentially a
[09:48] (588.88s)
dedicated chat window for Claude Code.
[09:50] (590.88s)
The installation process is
[09:52] (592.24s)
straightforward through the extensions
[09:53] (593.76s)
panel in either cursor or VS Code.
[09:55] (595.92s)
Simply open extensions, search for
[09:57] (597.92s)
Claude Code Chat, and you'll find the
[09:59] (599.68s)
extension you need. Once installed,
[10:01] (601.44s)
you'll have access to this impressive
[10:03] (603.12s)
Claude Code Chat interface. The user
[10:05] (605.20s)
interface is beautifully designed and
[10:07] (607.12s)
integrates seamlessly with your code
[10:09] (609.04s)
editor. You can select different models,
[10:11] (611.12s)
and when you enable thinking mode, you
[10:13] (613.04s)
have the option to adjust the level of
[10:14] (614.96s)
thinking as well. The integration fits
[10:17] (617.04s)
naturally into the cursor UI, creating a
[10:19] (619.44s)
cohesive experience. All the standard
[10:21] (621.52s)
features are available, including plan
[10:23] (623.52s)
mode and slash commands. It's truly a
[10:25] (625.68s)
complete package that enhances your
[10:27] (627.52s)
development workflow. While I've
[10:29] (629.04s)
demonstrated other interfaces in the
[10:31] (631.04s)
past, such as web UIs that allowed
[10:33] (633.44s)
claude code usage on mobile devices,
[10:35] (635.76s)
those were quite basic and didn't
[10:37] (637.20s)
support custom commands. This extension,
[10:39] (639.36s)
however, offers a comprehensive
[10:40] (640.96s)
solution. If you enjoy using cloud code
[10:43] (643.04s)
in cursor, this extension provides an
[10:45] (645.20s)
excellent way to enhance that
[10:46] (646.72s)
experience. For VS Code users, it's a
[10:49] (649.04s)
solid free option that's definitely
[10:50] (650.88s)
worth trying. That brings us to the end
[10:53] (653.12s)
of this video. If you'd like to support
[10:54] (654.80s)
the channel and help us keep making
[10:56] (656.56s)
videos like this, you can do so by using
[10:58] (658.64s)
the super thanks button below. As
[11:00] (660.56s)
always, thank you for watching and I'll
[11:02] (662.16s)
see you in the next one.