[00:00] (0.16s)
There have been many amazing frameworks
[00:02] (2.32s)
built on top of Claude code and they
[00:04] (4.40s)
exist because of one incredible feature,
[00:06] (6.88s)
custom commands. This feature
[00:08] (8.64s)
essentially transformed Claude Code into
[00:10] (10.72s)
a programmable agent that could take on
[00:12] (12.80s)
different roles. In one of our previous
[00:14] (14.72s)
videos, we featured a particularly
[00:16] (16.48s)
well-built framework that could turn
[00:18] (18.24s)
Claude Code into a multi-agent coding
[00:20] (20.48s)
team. Each member of this coding team
[00:22] (22.40s)
had their own custom commands tailored
[00:24] (24.40s)
to their specific role. But now
[00:26] (26.32s)
everything is about to change. Claude
[00:28] (28.16s)
Code just released a groundbreaking new
[00:30] (30.16s)
feature that allows us to create
[00:31] (31.84s)
different versions of Claude Code, each
[00:33] (33.92s)
specialized for specific tasks. This is
[00:36] (36.16s)
truly a game-changing feature that will
[00:38] (38.32s)
revolutionize how developers work with
[00:40] (40.40s)
AI coding assistance. The feature Claude
[00:43] (43.04s)
just released is called sub aents. As I
[00:45] (45.20s)
mentioned earlier, it allows you to
[00:46] (46.88s)
create specialized sub aents in claude
[00:49] (49.12s)
code for specific tasks. To understand
[00:51] (51.20s)
their potential, consider the BMAD
[00:53] (53.28s)
workflow and superclaw workflows we've
[00:55] (55.60s)
showcased on the channel. These
[00:57] (57.04s)
workflows feature different roles
[00:58] (58.88s)
executed through Claude's custom
[01:00] (60.72s)
commands. Now, those same custom
[01:02] (62.88s)
commands can evolve into dedicated
[01:04] (64.88s)
agents with deeper specialization. This
[01:07] (67.28s)
means you can create a complete
[01:08] (68.72s)
development team within Claude Code. You
[01:10] (70.80s)
might have a project manager, a scrum
[01:12] (72.72s)
manager, a developer, a UI expert, and
[01:15] (75.36s)
even a QA engineer who properly tests
[01:17] (77.84s)
code with specialized knowledge. Each
[01:19] (79.92s)
agent brings focused expertise to their
[01:22] (82.24s)
specific role. By combining these sub
[01:24] (84.24s)
aents, you can create incredibly
[01:26] (86.08s)
powerful workflows that go far beyond
[01:28] (88.32s)
simple automation. There's a compelling
[01:30] (90.16s)
reason why sub aents outperform the
[01:32] (92.40s)
basic claude commands people have been
[01:34] (94.48s)
implementing in claude code frameworks.
[01:36] (96.72s)
Now, a quick break to tell you about
[01:38] (98.64s)
today's sponsor, Test Sprite, an AI
[01:41] (101.20s)
testing platform built to fix your AI
[01:43] (103.68s)
generated code. But they just released a
[01:45] (105.84s)
game-changing feature, their MCP server.
[01:48] (108.56s)
Test sprite MCP server connects directly
[01:51] (111.36s)
to your IDE's AI coding agent tools like
[01:54] (114.32s)
cursor and other MCP compatible IDE such
[01:57] (117.44s)
as wind surf and claude code test sprite
[01:59] (119.92s)
MCP starts by understanding your product
[02:02] (122.24s)
goals by reading your repo and prompts.
[02:04] (124.40s)
It then builds smart test plans by
[02:06] (126.48s)
parsing product specs or natural
[02:08] (128.40s)
language intent and works with your
[02:10] (130.16s)
coding agent to validate the existing
[02:12] (132.24s)
codebase automatically. It generates
[02:14] (134.56s)
standardized PRDS, creates test plans,
[02:17] (137.20s)
and produces test cases and test code
[02:19] (139.44s)
without any manual input. From there, it
[02:21] (141.76s)
runs full front-end and back-end tests
[02:23] (143.76s)
in the cloud, diagnoses failures, and
[02:26] (146.08s)
sends structured reports back to your AI
[02:28] (148.24s)
coder, telling it exactly what's broken
[02:30] (150.24s)
or missing. Compared to the 40% accuracy
[02:32] (152.96s)
of typical Vibe coding tools, Test
[02:35] (155.20s)
Sprite MCP boosts accuracy to above 90%.
[02:38] (158.80s)
All without prompts or manual effort.
[02:41] (161.04s)
That's why it's trending in the
[02:42] (162.40s)
developer community and recently hit
[02:44] (164.40s)
number one on Product Hunt. Check out
[02:46] (166.24s)
the link in the description to try test
[02:48] (168.16s)
sprite MCP for free. Now, back to the
[02:50] (170.64s)
video. Before diving deep into sub
[02:52] (172.96s)
agents and creating powerful workflows,
[02:55] (175.36s)
let me walk you through this new feature
[02:57] (177.12s)
and its setup options. I'll initialize
[02:59] (179.44s)
Claude and enter the slash command, then
[03:01] (181.52s)
type out agents. You'll notice this new
[03:03] (183.84s)
slash command for managing agent
[03:05] (185.76s)
configuration. When I enter it, there
[03:07] (187.44s)
are no existing agents. So, it presents
[03:09] (189.44s)
the option to create a new one. Creating
[03:11] (191.44s)
a project level agent displays it in
[03:13] (193.44s)
your project list. For instance, I
[03:15] (195.36s)
created a UI creator which now appears
[03:17] (197.52s)
under project agents. Press enter to
[03:19] (199.68s)
create a new agent. Two options appear.
[03:21] (201.92s)
Create a personal agent which works
[03:23] (203.84s)
globally across all cloud sessions or a
[03:26] (206.32s)
project agent limited to the current
[03:28] (208.16s)
project. Let's continue with the project
[03:30] (210.08s)
agent. The next step involves choosing
[03:32] (212.32s)
your creation method. While manual
[03:34] (214.24s)
configuration is available, Claude
[03:36] (216.08s)
recommends starting with an
[03:37] (217.44s)
autogenerated agent based on your needs.
[03:39] (219.92s)
This provides a solid foundation you can
[03:42] (222.16s)
customize later. Select generate with
[03:44] (224.56s)
Claude and provide a general description
[03:46] (226.64s)
of your agents purpose. For a UI expert
[03:49] (229.28s)
agent, you might use this prompt. The
[03:51] (231.20s)
agent should create attractive UIs
[03:53] (233.20s)
regardless of content incorporating best
[03:55] (235.52s)
practices for visual appeal. The agent
[03:57] (237.60s)
needs context about color palettes,
[03:59] (239.76s)
element arrangement, and user experience
[04:01] (241.92s)
principles. For mobile UI prototypes, it
[04:04] (244.48s)
should include platform specific
[04:06] (246.16s)
guidelines. After entering your
[04:07] (247.84s)
description, Claude generates the agent
[04:09] (249.92s)
configuration. Next comes tool
[04:11] (251.84s)
selection. All tools are selected by
[04:13] (253.76s)
default, but you should only grant
[04:15] (255.36s)
necessary ones. This improves both
[04:17] (257.20s)
security and performance by maintaining
[04:19] (259.20s)
focus. For our UI agent, I'll deselect
[04:21] (261.76s)
MCP tools since they're not needed.
[04:23] (263.68s)
Continue to the naming step where Claude
[04:25] (265.84s)
suggests UI design expert. Choose a
[04:28] (268.32s)
color for your agent. Then review the
[04:30] (270.16s)
preview. Press S to save. Your new UI
[04:32] (272.88s)
design expert now appears under project
[04:35] (275.20s)
agents. Opening your project in cursor
[04:37] (277.52s)
reveals a Claude folder containing your
[04:39] (279.52s)
agents markdown file. This file includes
[04:41] (281.92s)
the complete system prompt and
[04:43] (283.60s)
specifications. Claude has configured
[04:45] (285.52s)
this agent to create visually appealing
[04:47] (287.68s)
interfaces across any text stack.
[04:49] (289.76s)
However, for optimal performance,
[04:51] (291.68s)
consider creating specialized agents for
[04:53] (293.92s)
specific tasks. A dedicated mobile
[04:56] (296.00s)
prototype agent would perform better
[04:57] (297.84s)
than a general UI agent. You might
[05:00] (300.16s)
wonder how these sub agents differ from
[05:02] (302.16s)
the custom commands we've been using.
[05:04] (304.08s)
Previous videos and many frameworks
[05:06] (306.00s)
featured on the channel have shown how
[05:07] (307.68s)
specialized custom commands orchestrate
[05:09] (309.84s)
workflows effectively. While custom
[05:11] (311.76s)
commands have served us well, the key
[05:13] (313.84s)
difference with sub aents lies in
[05:15] (315.84s)
context management. Sub aents initialize
[05:18] (318.40s)
with their own context window completely
[05:20] (320.88s)
separate from the main conversation.
[05:22] (322.72s)
When your main agent activates a sub
[05:24] (324.56s)
aent, that sub aent launches in its own
[05:26] (326.88s)
isolated environment. Let me illustrate
[05:29] (329.12s)
with this UI design agent example. It
[05:31] (331.68s)
launched independently, used one tool,
[05:34] (334.24s)
consumed 30.7K tokens and ran for
[05:37] (337.28s)
approximately 2 minutes. Throughout this
[05:39] (339.36s)
entire process, its context window
[05:41] (341.52s)
remained entirely separate from the main
[05:43] (343.52s)
agent. Once sub agents complete their
[05:45] (345.84s)
tasks, they send a concise summary back
[05:48] (348.08s)
to the main agent reporting what they
[05:50] (350.08s)
accomplished. This architecture ensures
[05:52] (352.24s)
each agent retains only the context it
[05:54] (354.80s)
needs, preventing your main context
[05:56] (356.72s)
window from becoming cluttered with
[05:58] (358.48s)
irrelevant information. The result is a
[06:00] (360.72s)
cleaner, more efficient system where
[06:02] (362.64s)
specialized agents handle specific tasks
[06:05] (365.20s)
without overwhelming the primary
[06:06] (366.96s)
conversation thread. Previously, I
[06:08] (368.88s)
implemented a workflow using the Shad CN
[06:11] (371.28s)
UI MCP server, which proved really
[06:13] (373.60s)
valuable for creating user interfaces.
[06:15] (375.84s)
The MCP server provided direct context
[06:18] (378.24s)
of the Shad CN elements to the AI agent,
[06:20] (380.88s)
enabling it to build quality interfaces
[06:23] (383.12s)
with everything properly connected and
[06:24] (384.88s)
configured. What makes these sub aents
[06:26] (386.96s)
particularly powerful is how they create
[06:29] (389.04s)
fresh instances with empty context
[06:31] (391.28s)
windows. This gives us a significant
[06:33] (393.28s)
advantage when sending requests to the
[06:35] (395.28s)
SHAD CN UI agent. It starts with a clean
[06:38] (398.08s)
slate which results in superior UI
[06:40] (400.32s)
creation. To demonstrate this, I've
[06:42] (402.24s)
prepared a comprehensive prompt
[06:43] (403.84s)
containing all rules from my previous
[06:45] (405.84s)
video along with the exact workflow
[06:47] (407.84s)
instructions. This enables the agent to
[06:50] (410.00s)
execute the entire process autonomously.
[06:52] (412.40s)
Here's how it works. The agent first
[06:54] (414.24s)
receives a file reference containing
[06:56] (416.00s)
either a structure specification or a
[06:58] (418.00s)
creation prompt. I've included my Shad
[07:00] (420.08s)
CN MCP rules which mandate that all Shad
[07:02] (422.96s)
CNN components must route through the
[07:04] (424.72s)
MCP server without exceptions. The
[07:06] (426.80s)
prompt covers planning stage
[07:08] (428.40s)
requirements, implementation guidelines,
[07:10] (430.64s)
and the complete UI implementation
[07:12] (432.72s)
workflow. Don't worry if you're
[07:14] (434.32s)
unfamiliar with this process. Everything
[07:16] (436.32s)
will become clear as we progress through
[07:18] (438.24s)
the demonstration. Let me copy this
[07:20] (440.16s)
complete prompt and return to my
[07:21] (441.68s)
terminal. In Claude, I'll create a new
[07:23] (443.84s)
project level agent using the generate
[07:25] (445.92s)
with Claude option. I'll paste my
[07:27] (447.84s)
detailed prompt that explains the
[07:29] (449.44s)
workflow mechanics and agent
[07:31] (451.04s)
responsibilities. Claude will now
[07:32] (452.80s)
generate the agent configuration based
[07:34] (454.88s)
on our specifications. For tools, we
[07:37] (457.12s)
need read and edit capabilities plus MCP
[07:39] (459.92s)
servers. We'll disable web search tools
[07:42] (462.16s)
since they're unnecessary for this task.
[07:44] (464.16s)
The agent only needs to reference
[07:45] (465.84s)
available Shad CN UI components. Claude
[07:48] (468.48s)
has named it Shad CN UI builder. After
[07:51] (471.28s)
selecting a color and pressing S to
[07:53] (473.36s)
save, our new Shad CN UI builder appears
[07:56] (476.24s)
in the project agents list, ready for
[07:58] (478.32s)
use. I've now instructed Claude to
[08:00] (480.88s)
implement the app that I referenced
[08:02] (482.56s)
further ahead in the prompt specifically
[08:04] (484.56s)
using Nex.js with shad CN components.
[08:07] (487.44s)
Let me show you visually what was made
[08:09] (489.12s)
in cursor where I have the project open.
[08:11] (491.28s)
I placed an integration store.md file
[08:14] (494.32s)
containing the front-end app
[08:15] (495.92s)
specifications and the navigation
[08:17] (497.84s)
structure between different pages. This
[08:20] (500.16s)
serves as the blueprint for what we're
[08:21] (501.92s)
building. The shaden agent created this
[08:24] (504.08s)
next.js application following our
[08:26] (506.00s)
workflow. It began by generating UI
[08:28] (508.24s)
implementation.m MD which documents all
[08:30] (510.96s)
patterns and components used in building
[08:32] (512.88s)
the integration store. Looking at the
[08:34] (514.72s)
execution, you can see the shad CN agent
[08:37] (517.28s)
activated immediately after my prompt.
[08:39] (519.44s)
Notice it consumed 72K tokens from its
[08:42] (522.32s)
own context window, leaving our main
[08:44] (524.40s)
sessions context unaffected. This
[08:46] (526.56s)
demonstrates the efficiency of using sub
[08:48] (528.56s)
aents. The agent completed the
[08:50] (530.32s)
integration successfully. Let me show
[08:52] (532.24s)
you the resulting integration store.
[08:54] (534.08s)
While the color scheme and styling need
[08:56] (536.00s)
refinement, the foundation is solid. The
[08:58] (538.08s)
Shad CN components are properly
[09:00] (540.00s)
structured and page navigation works
[09:02] (542.16s)
correctly. Opening the details page
[09:04] (544.16s)
displays the expected information. The
[09:06] (546.16s)
API key generation feature includes
[09:08] (548.40s)
proper notifications, copy
[09:10] (550.00s)
functionality, and connection approval
[09:12] (552.00s)
with smooth animations. Everything
[09:13] (553.92s)
functions as intended. The structure is
[09:16] (556.00s)
complete and working properly. Now, we
[09:17] (557.92s)
simply need to apply proper styling
[09:19] (559.92s)
which can be accomplished using the
[09:21] (561.52s)
appropriate tools. The site I'm going to
[09:23] (563.92s)
be using is Tweak CN, and we've featured
[09:26] (566.32s)
it in previous videos as well. It's an
[09:28] (568.48s)
excellent tool for customizing your Shad
[09:30] (570.48s)
CN components after establishing your
[09:32] (572.48s)
base structure, which we've already
[09:34] (574.00s)
done. To demonstrate its capabilities,
[09:36] (576.00s)
I'll take a screenshot of this Gumroad
[09:38] (578.00s)
landing page and then go back to tweak
[09:40] (580.16s)
CN. What makes this tool particularly
[09:42] (582.40s)
useful is their recently launched
[09:44] (584.32s)
feature that automatically generates
[09:46] (586.32s)
different themes using a reference
[09:48] (588.32s)
image. In our case, we're providing this
[09:50] (590.32s)
Gumroad landing page as our reference.
[09:52] (592.48s)
You can see the generated theme
[09:54] (594.08s)
displayed here. When I provided the
[09:55] (595.76s)
Gumroad landing page screenshot, it
[09:58] (598.00s)
recognized the design, extracted the
[10:00] (600.00s)
colors, and created multiple theme
[10:02] (602.00s)
variations for us to choose from. Once I
[10:04] (604.16s)
was satisfied with the theme, I copied
[10:06] (606.16s)
the generated code. Since my project
[10:08] (608.16s)
uses Tailwind Fe 3, I made sure to copy
[10:10] (610.88s)
the corresponding index.css file. Then,
[10:14] (614.24s)
returning to Claude Code, I followed the
[10:16] (616.32s)
specified format and pasted the code I
[10:18] (618.88s)
had just copied. The system seamlessly
[10:21] (621.04s)
called the Shad CN agent to replace the
[10:23] (623.52s)
original theme with my new custom theme.
[10:25] (625.76s)
The entire process took approximately 4
[10:27] (627.76s)
minutes and consumed 46,000 tokens, but
[10:30] (630.48s)
the theme was successfully applied. Let
[10:32] (632.48s)
me show you the results. After applying
[10:34] (634.80s)
the theme, this is what it made. I asked
[10:36] (636.96s)
it to remove the emojis since they
[10:38] (638.80s)
clashed with the design. And in dark
[10:40] (640.56s)
mode, you can see how everything
[10:42] (642.08s)
integrates beautifully. The structure
[10:43] (643.92s)
works exceptionally well, which brings
[10:45] (645.76s)
up an interesting point. If I had tried
[10:47] (647.76s)
building this front end with Shad CN
[10:49] (649.92s)
components without MCP and Claude's
[10:52] (652.08s)
agents, it would typically introduce
[10:54] (654.16s)
numerous structural bugs. But here's
[10:56] (656.08s)
where Claude's agents really shine. They
[10:58] (658.24s)
maintain individual context windows, and
[11:00] (660.40s)
that's what ensures such smooth
[11:01] (661.92s)
implementation throughout the entire
[11:03] (663.60s)
process. When testing the functionality
[11:05] (665.68s)
by approving the API key, I noticed the
[11:08] (668.16s)
connection succeeds immediately and
[11:10] (670.16s)
everything functions exactly as
[11:11] (671.92s)
expected, which demonstrates how well
[11:14] (674.08s)
integrated the system is. Now, I should
[11:16] (676.24s)
mention that what you're seeing
[11:17] (677.52s)
represents multiple testing iterations
[11:19] (679.68s)
with many refinements made along the
[11:21] (681.52s)
way. While it's working impressively
[11:23] (683.28s)
well at this stage, implementing a
[11:25] (685.04s)
proper backend would fully complete this
[11:27] (687.04s)
app. Now, from the demo I gave you and
[11:29] (689.84s)
the things I explained earlier, you must
[11:31] (691.84s)
have already understood the key benefits
[11:33] (693.84s)
of using sub aents. The context gets
[11:36] (696.40s)
preserved and essentially you're
[11:38] (698.00s)
creating specialized agents that you can
[11:40] (700.24s)
reuse again and again. You also get the
[11:42] (702.56s)
ability to control each tool the agent
[11:44] (704.72s)
uses, which wasn't possible with the
[11:46] (706.56s)
slash commands. There are a few other
[11:48] (708.48s)
things you need to know that will make
[11:49] (709.92s)
it easier for you to use these sub aents
[11:52] (712.32s)
effectively. There are two ways that
[11:54] (714.16s)
these sub aents can be called. The first
[11:56] (716.24s)
way is that Claude Code will
[11:57] (717.92s)
automatically choose which agent to use.
[12:00] (720.24s)
As you saw in our demo, Claude Code
[12:02] (722.32s)
automatically picked up the Shad CN
[12:04] (724.32s)
agent whenever it was needed. when the
[12:06] (726.16s)
theme needed to be applied or when the
[12:08] (728.00s)
actual app needed to be built, it
[12:09] (729.68s)
automatically selected the shad CN
[12:11] (731.68s)
agent. This happened because the
[12:13] (733.36s)
description we provided was very well
[12:15] (735.36s)
written. The description for each agent
[12:17] (737.52s)
is really crucial. If cla code is not
[12:19] (739.92s)
able to pick up your agent when it's
[12:21] (741.76s)
needed, it's probably because your task
[12:23] (743.84s)
description isn't effective enough. That
[12:26] (746.08s)
purple text you see defining the agents
[12:28] (748.08s)
purpose needs to be clear and specific.
[12:30] (750.08s)
The second way to call sub agents is by
[12:32] (752.32s)
specifically mentioning that Claude code
[12:34] (754.40s)
has to use a particular agent. If you
[12:36] (756.40s)
look at the documentation Claude Code
[12:38] (758.24s)
has provided, you'll also see some
[12:40] (760.00s)
examples of agents. I've linked this in
[12:42] (762.08s)
the description below so you can check
[12:43] (763.76s)
it out and learn from their examples. I
[12:46] (766.08s)
also found a sub agents collection on
[12:48] (768.08s)
GitHub where you can grab whichever ones
[12:50] (770.00s)
you need for your tasks. This is a great
[12:52] (772.08s)
resource for getting started quickly.
[12:53] (773.92s)
Here's where things get really powerful.
[12:55] (775.68s)
You can chain different sub aents
[12:57] (777.36s)
together. And this is where you can
[12:58] (778.96s)
combine sub aents with custom/comands.
[13:02] (782.08s)
For example, you could create a custom
[13:03] (783.92s)
command that uses a code analyzer sub
[13:06] (786.40s)
aent to find performance issues and then
[13:08] (788.72s)
automatically triggers an optimizer sub
[13:10] (790.88s)
aent to fix them. You could put this
[13:12] (792.64s)
into a single custom command and simply
[13:14] (794.80s)
run that command to automatically call
[13:16] (796.80s)
those two sub aents in sequence. This
[13:18] (798.88s)
chain workflow saves you time and
[13:20] (800.72s)
ensures consistent results every time
[13:22] (802.64s)
you run it. That brings us to the end of
[13:24] (804.80s)
this video. If you'd like to support the
[13:26] (806.56s)
channel and help us keep making videos
[13:28] (808.48s)
like this, you can do so by using the
[13:30] (810.48s)
super thanks button below. As always,
[13:32] (812.56s)
thank you for watching and I'll see you
[13:34] (814.16s)
in the next one.