[00:00] (0.16s)
Claude Code has now become super cheap
[00:02] (2.40s)
because they've brought it onto the $20
[00:04] (4.48s)
pro plan and the $200 max plan instead
[00:07] (7.60s)
of API usage, and that's why it's become
[00:10] (10.08s)
my go-to coding agent. You've probably
[00:12] (12.16s)
watched tons of tutorials on it, but
[00:14] (14.08s)
here are some amazing features and tips
[00:16] (16.16s)
that you might have missed. And I
[00:17] (17.68s)
promise you that knowing about them is
[00:19] (19.60s)
going to make you 10 times more
[00:21] (21.20s)
productive with Claude Code. And at the
[00:23] (23.04s)
end of the video, I'll also let you know
[00:24] (24.80s)
the key method that you can use to push
[00:26] (26.80s)
Claude Code to its maximum power. Okay,
[00:29] (29.60s)
so the very first feature that I want to
[00:31] (31.68s)
show you and that I don't think you've
[00:33] (33.20s)
seen before is making custom workflows
[00:35] (35.68s)
or you might even say custom agents in
[00:38] (38.00s)
Claude code. Let me just fire up Claude
[00:40] (40.16s)
so you can see what I'm talking about.
[00:41] (41.92s)
So if you head into your Claude and type
[00:44] (44.00s)
these slash commands, you get multiple
[00:46] (46.24s)
commands that allow you to take
[00:47] (47.76s)
advantage of Claude's amazing
[00:49] (49.36s)
capabilities. But you'll see here that I
[00:51] (51.44s)
have this command called search web. And
[00:53] (53.36s)
if you go into Claude code, you won't
[00:55] (55.20s)
have this here. That's because this is a
[00:57] (57.28s)
custom/comand I've made myself. If I go
[01:00] (60.24s)
ahead and ask it to do something like
[01:02] (62.16s)
for example, how do I use the custom
[01:04] (64.32s)
claw feature in claude code, you'll see
[01:06] (66.56s)
that it's going to search the web for
[01:08] (68.24s)
that term and get me the most to the
[01:10] (70.24s)
point solution to my problem. And you
[01:12] (72.32s)
can see that it has returned detailed
[01:14] (74.16s)
output on how to use this custom command
[01:16] (76.64s)
feature. So what are these custom
[01:18] (78.32s)
commands? These are essentially reusable
[01:20] (80.72s)
prompts with arguments if you choose to
[01:22] (82.80s)
add them that allow you to build custom
[01:25] (85.04s)
workflows Claude Code can execute for
[01:27] (87.36s)
you. That way you don't need to repeat
[01:29] (89.44s)
the same prompt again and again. You
[01:31] (91.68s)
just create these custom/comands once
[01:34] (94.24s)
and Claude Code will do it for you. Now,
[01:36] (96.24s)
how do you create these custom/comands?
[01:38] (98.40s)
Let me show you. First, you're going to
[01:40] (100.08s)
go to your base directory and paste this
[01:42] (102.24s)
command which will create a commands
[01:44] (104.00s)
folder inside Claude Code. That folder
[01:46] (106.32s)
is where you'll create your custom
[01:47] (107.92s)
workflows. If I go into that folder and
[01:50] (110.16s)
open it up, you can use any text editor
[01:52] (112.32s)
you like. I'll just open it in cursor.
[01:54] (114.32s)
You'll see we have this search webb.md
[01:56] (116.72s)
file. These MD files are the slash
[01:59] (119.20s)
commands that will show up in cloud
[02:01] (121.04s)
code. For example, you can see I've laid
[02:03] (123.20s)
out this prompt here telling it to
[02:04] (124.96s)
search the web for the given argument.
[02:06] (126.96s)
This is how you define arguments, the
[02:08] (128.88s)
dynamic part of the prompt that changes
[02:10] (130.96s)
every time you run it. And I've asked it
[02:12] (132.88s)
to return the most relevant information
[02:14] (134.88s)
about the search query. Now, if we want
[02:17] (137.04s)
to create another custom workflow, for
[02:19] (139.28s)
example, a codebase explainer, we would
[02:21] (141.44s)
create another file and name it explain
[02:23] (143.84s)
codebase.md. In here, we'll write out
[02:26] (146.56s)
our custom prompt. For instance, we're
[02:28] (148.64s)
going to ask it to scan the whole
[02:30] (150.40s)
codebase and explain it to us in an easy
[02:33] (153.20s)
way that helps us understand how it
[02:35] (155.44s)
functions and how everything is
[02:37] (157.04s)
connected. This becomes a reusable
[02:38] (158.88s)
prompt and every time I call this custom
[02:41] (161.28s)
command, it will just run that prompt
[02:43] (163.20s)
automatically. So if I go back since
[02:45] (165.44s)
I've updated the commands folder, I need
[02:47] (167.60s)
to restart cla code first so it can
[02:49] (169.92s)
recognize the new command. And now if I
[02:52] (172.24s)
type the /ash command, you'll see that
[02:54] (174.16s)
we have our explain codebase tool which
[02:56] (176.48s)
will explain the whole codebase and how
[02:58] (178.48s)
it functions. Before we continue to the
[03:00] (180.80s)
second feature, let me show you another
[03:02] (182.56s)
cool thing. You've probably heard that
[03:04] (184.40s)
you can now use clawed code inside
[03:06] (186.64s)
cursor or windsurf. And if you're using
[03:08] (188.72s)
this feature, there is one thing you
[03:10] (190.80s)
definitely need to do. Otherwise, you're
[03:13] (193.04s)
going to have a frustrating experience.
[03:14] (194.96s)
First, for those who don't know, let me
[03:16] (196.88s)
show you how to get claude code inside
[03:18] (198.80s)
your terminal. You open up your terminal
[03:20] (200.88s)
inside cursor and just type the claud
[03:23] (203.04s)
command. This initializes claude code
[03:25] (205.20s)
and automatically recognizes that you're
[03:27] (207.20s)
inside cursor. Then installs the claude
[03:29] (209.36s)
code extension. Now you can see it's
[03:31] (211.28s)
been installed. What we need to do is
[03:33] (213.28s)
press command plus escape which will
[03:35] (215.52s)
open up claude code for us inside
[03:37] (217.76s)
cursor. You can see that claude code is
[03:39] (219.92s)
now initialized in cursor and it's going
[03:42] (222.08s)
to receive everything. All the errors
[03:44] (224.16s)
from cursor can also be passed to claude
[03:46] (226.48s)
code. Now, here's something you probably
[03:48] (228.24s)
didn't know. If you're using cloud code
[03:50] (230.24s)
and want to write multi-line prompts or
[03:52] (232.40s)
structure your prompts properly, you're
[03:54] (234.32s)
probably facing a major issue. For
[03:56] (236.24s)
example, if I want to make a website and
[03:58] (238.48s)
give it specifications on the next line,
[04:00] (240.64s)
when I press either shift plus enter or
[04:03] (243.12s)
just enter, you'll see that it starts
[04:05] (245.12s)
running the prompt immediately. This is
[04:07] (247.12s)
not the usual behavior you'd expect
[04:09] (249.12s)
inside cursor. So, how do you get that
[04:11] (251.44s)
multi-line editing feature in claude
[04:13] (253.52s)
code? There's a special command that's
[04:15] (255.36s)
only available in cursor. It's not
[04:17] (257.28s)
available in your regular terminal. Once
[04:19] (259.20s)
you enter this command, it sets up
[04:21] (261.12s)
cursor terminal key bindings, allowing
[04:23] (263.36s)
you to write multi-line prompts
[04:25] (265.12s)
properly. So, now when I type, I can
[04:26] (266.88s)
move to the next line and give it
[04:28] (268.48s)
different details without accidentally
[04:30] (270.32s)
triggering the prompt. Oh, and if you're
[04:32] (272.64s)
enjoying the content we're making, I'd
[04:34] (274.56s)
really appreciate it if you hit that
[04:36] (276.16s)
subscribe button. We're also testing out
[04:38] (278.16s)
channel memberships, launch the first
[04:40] (280.00s)
tier as a test, and 50 people jumped in
[04:42] (282.40s)
immediately. The support's been
[04:43] (283.92s)
incredible, so we're thinking about
[04:45] (285.60s)
launching additional tiers. Right now,
[04:48] (288.00s)
members get priority replies to your
[04:50] (290.08s)
comments. Perfect if you need feedback
[04:52] (292.00s)
or have questions. Now, the second
[04:54] (294.16s)
feature that I want to tell you about
[04:55] (295.60s)
Claude Code is that you can actually use
[04:57] (297.76s)
MCP servers with it. And I don't know if
[05:00] (300.08s)
you've been using different MCP servers
[05:02] (302.08s)
in cloud code, but it's a gamecher. If
[05:04] (304.40s)
you haven't, I'll show you a great
[05:05] (305.84s)
example of why it's useful and how you
[05:07] (307.92s)
can set them up yourself. So, if I use
[05:10] (310.16s)
the /ash command and open up the manage
[05:12] (312.48s)
MCP server section, you'll see that the
[05:14] (314.72s)
Sentry MCP has been connected to clawed
[05:17] (317.04s)
code. You can clearly see in this video,
[05:19] (319.28s)
Sentry is a platform where you manage
[05:21] (321.28s)
issues in your code. It's an amazing
[05:23] (323.20s)
platform that software developers have
[05:25] (325.20s)
been using for a long time and its MCP
[05:27] (327.68s)
server takes it to the next level. We
[05:29] (329.68s)
also made a video on it. You can see in
[05:31] (331.52s)
the video that it can fetch issue
[05:33] (333.20s)
details about a particular project.
[05:35] (335.20s)
Using those details, your AI agents,
[05:37] (337.60s)
whether it's clawed or cursor, gain much
[05:39] (339.84s)
more insight for solving that issue and
[05:41] (341.84s)
debugging it. It even has its own AI
[05:44] (344.16s)
powered agent that helps you solve these
[05:46] (346.16s)
problems. This is why using MCP servers
[05:48] (348.88s)
in claude code is so important. It adds
[05:51] (351.28s)
so much functionality and Sentry isn't
[05:53] (353.52s)
the only one. You can add so many more
[05:55] (355.52s)
amazing MCP servers. I'll leave some
[05:57] (357.92s)
links down below to our videos on other
[06:00] (360.08s)
MCP servers that you should definitely
[06:02] (362.32s)
check out. Now, the next question is how
[06:04] (364.80s)
do you install these MCP servers for
[06:07] (367.04s)
Claude Code? I'm going to give you the
[06:08] (368.80s)
most straightforward method so that the
[06:10] (370.80s)
existing JSON configuration you're using
[06:13] (373.20s)
with Cursor and Windsurf also works with
[06:15] (375.52s)
Claude Code. First, you'll want to exit
[06:17] (377.84s)
claude code so you can add your MCP
[06:19] (379.84s)
servers. Then you're going to paste in a
[06:21] (381.68s)
command like this. So what's happening
[06:23] (383.76s)
in this command? You write claud
[06:25] (385.44s)
followed by MCP. And then since we're
[06:27] (387.84s)
adding JSON in this method, we use the
[06:29] (389.92s)
add JSON method. Next comes the name of
[06:32] (392.08s)
the MCP server, which in our case we
[06:34] (394.40s)
want to set as sentry. This is the name
[06:36] (396.48s)
you define. It's not hard-coded, so you
[06:38] (398.88s)
can change it, but as a best practice,
[06:40] (400.72s)
it's usually a good idea to use the same
[06:42] (402.88s)
name you see in the configuration. For
[06:44] (404.96s)
example, you'll see that this is the
[06:46] (406.64s)
JSON for the Sentry MCP. You just copy
[06:49] (409.36s)
it specifically this part of the JSON
[06:51] (411.60s)
and go back and put that after the name
[06:53] (413.68s)
inside single quotes. So you can see
[06:56] (416.00s)
first we wrote the name we wanted which
[06:57] (417.92s)
was sentry. Then we added a single
[06:59] (419.84s)
quote, pasted the highlighted part of
[07:01] (421.68s)
the JSON from earlier and closed it off.
[07:03] (423.92s)
If you run this command, it will add the
[07:05] (425.76s)
Sentry MCP to Claude code. To verify
[07:08] (428.48s)
this, just open claude code again, use
[07:10] (430.80s)
the MCP command, and you'll see that the
[07:13] (433.04s)
Sentry MCP is available and ready for
[07:15] (435.44s)
you to use. Another useful thing about
[07:17] (437.76s)
slash commands is that you can use MCPS
[07:20] (440.24s)
directly with them. For example, if I
[07:22] (442.24s)
type the slash command with MCP, you'll
[07:24] (444.56s)
see that the Sentry MCP provides us with
[07:26] (446.96s)
two commands that include arguments we
[07:28] (448.96s)
can use. One is find errors in a file,
[07:31] (451.28s)
and the other is fix issues with SEIR,
[07:33] (453.60s)
which is their AI agent I mentioned
[07:35] (455.52s)
earlier. When I enter this command, I
[07:37] (457.76s)
need to provide an issue ID as an
[07:39] (459.84s)
argument. This tells it exactly what
[07:41] (461.84s)
issue to fix with Seir. This essentially
[07:44] (464.16s)
turns it into a programmable tool that
[07:46] (466.56s)
you can call whenever you need it. Now,
[07:48] (468.64s)
before I tell you how to push Claude
[07:50] (470.24s)
Code to its maximum limit, let me tell
[07:52] (472.24s)
you about the final feature. Claude Code
[07:54] (474.40s)
now has a new option called plan mode,
[07:56] (476.48s)
which allows you to plan out your whole
[07:58] (478.32s)
project or idea. It's basically a way to
[08:00] (480.96s)
brainstorm anything with clawed code and
[08:03] (483.44s)
you can access it by pressing shift plus
[08:05] (485.84s)
tab to switch modes. As you can see,
[08:08] (488.64s)
plan mode has been turned on. You can
[08:10] (490.80s)
also switch into auto accept edits mode.
[08:13] (493.60s)
This mode will edit files without asking
[08:15] (495.68s)
for your permission. It's definitely
[08:17] (497.28s)
better when you want to give full
[08:18] (498.56s)
autonomy to Claude Code and just let it
[08:20] (500.64s)
do its thing. When you're in plan mode,
[08:22] (502.72s)
you can type out your ideas, whatever
[08:24] (504.64s)
you want to brainstorm, and it will
[08:26] (506.32s)
flesh out your thoughts, give you more
[08:28] (508.16s)
clarity, and even allow you to put it
[08:30] (510.08s)
into the claude.mmd file, which you can
[08:32] (512.32s)
initialize using a slash command. This
[08:34] (514.64s)
file is essentially a rule file for
[08:36] (516.96s)
Claude code, and Claude will follow it.
[08:39] (519.12s)
You can include anything in it,
[08:40] (520.64s)
codebased, documentation, specific
[08:42] (522.80s)
rules, and it will help guide your
[08:44] (524.72s)
workflow. There's also install GitHub
[08:46] (526.72s)
app, which is an amazing GitHub app.
[08:48] (528.56s)
We've featured it in another one of our
[08:50] (530.24s)
videos where we discussed the Claude SDK
[08:52] (532.72s)
which now allows you to embed Claude
[08:54] (534.64s)
code into AI applications. Yeah, you
[08:56] (536.96s)
heard that right. You can actually put
[08:58] (538.32s)
Claude code into apps and program it. So
[09:00] (540.88s)
definitely check that video out as well.
[09:02] (542.88s)
Now, here's how you push Claude code to
[09:04] (544.88s)
its maximum limits. Well, you just need
[09:06] (546.88s)
to use one keyword and it's called
[09:08] (548.80s)
Ultraink. If you think I'm just making
[09:10] (550.88s)
this up, you can actually see that
[09:12] (552.64s)
Claude themselves have referenced this,
[09:14] (554.64s)
that using the keyword ultrathink will
[09:16] (556.88s)
push Claude code and the models it uses
[09:19] (559.12s)
to maximum power. You should only use it
[09:21] (561.20s)
for your hardest problems that Claude
[09:23] (563.04s)
can't solve in its normal state. That
[09:25] (565.36s)
brings us to the end of this video. If
[09:27] (567.12s)
you like the Sentry MCP, do check out
[09:29] (569.44s)
our video on that as well. If you found
[09:31] (571.44s)
these methods helpful and want to
[09:33] (573.20s)
support the channel, you can use the
[09:34] (574.80s)
super thanks button below. It really
[09:36] (576.72s)
helps us keep making tutorials like
[09:38] (578.56s)
this. Thanks for watching and I'll see
[09:40] (580.32s)
you in the next