[00:00] (0.00s)
All right, so Claude Code just keeps
[00:01] (1.84s)
delivering. So Sid put a post out. He's
[00:04] (4.32s)
one of the engineers at Anthropic. And
[00:06] (6.32s)
when I saw him and followed him earlier
[00:08] (8.08s)
today, it was around 400 followers. You
[00:10] (10.00s)
can see that this post has already got
[00:11] (11.68s)
over 390,000 views. And Cloud Code has
[00:15] (15.20s)
just released the coolest feature yet.
[00:16] (16.80s)
It's called agent mode. So now you can
[00:19] (19.04s)
have a contextbound agent directly in
[00:21] (21.68s)
your Cloud Code terminal. So you can
[00:23] (23.60s)
give them very specific specialized
[00:25] (25.84s)
tasks. As you see here, it's showing a
[00:27] (27.92s)
demonstration of a back-end architect, a
[00:30] (30.48s)
front-end developer, and it just goes on
[00:32] (32.88s)
and on. So, I haven't seen any posts of
[00:35] (35.28s)
anyone actually putting some of their
[00:36] (36.72s)
system prompts out. So, we're going to
[00:38] (38.24s)
do this live here. So, first thing we
[00:40] (40.48s)
can do here, if you go to the Anthropic
[00:42] (42.88s)
documentation, you'll see that it walks
[00:44] (44.88s)
through how to create a new agent, where
[00:47] (47.12s)
it's located, whether a project-based
[00:49] (49.28s)
agent or one for your user that is
[00:52] (52.24s)
global for your entire system. So, what
[00:54] (54.40s)
we're going to do here is why not use
[00:56] (56.56s)
Claude to create the Claude agents. So,
[00:59] (59.44s)
I went over and I created a system
[01:01] (61.28s)
prompt here that says you're an expert
[01:02] (62.80s)
in writing highly effective LM system
[01:04] (64.96s)
prompts. So, I'm not going to read
[01:06] (66.24s)
through all of this, but essentially I'm
[01:07] (67.68s)
giving the documentation that says,
[01:09] (69.20s)
"Hey, Claude, go look at your own sub
[01:11] (71.52s)
agent documentation and then I'd like
[01:13] (73.60s)
you to reference Superclaude." And what
[01:16] (76.48s)
Supercloud is is this is super great.
[01:18] (78.56s)
Like before we had agent mode, we were
[01:20] (80.40s)
using Superclaude here to have these
[01:22] (82.72s)
different personas. So the personas of
[01:25] (85.04s)
an architect, the personas of a security
[01:27] (87.12s)
engineer, personas of a front-end
[01:28] (88.96s)
engineer, we already have some of this
[01:31] (91.20s)
this information baked in and supercloud
[01:34] (94.08s)
also comes with key principles. So these
[01:36] (96.88s)
are software development core principles
[01:38] (98.96s)
for coding standards that you have here
[01:41] (101.12s)
and rules of engagement to walk through
[01:43] (103.68s)
what are some of the actionable rules
[01:45] (105.28s)
that you would have as part of these.
[01:46] (106.88s)
So, as part of this prompt that we're
[01:48] (108.32s)
writing here in Claude, it's going to go
[01:50] (110.16s)
ahead here and build out some of the
[01:51] (111.92s)
different rules and ways that we can go
[01:54] (114.32s)
ahead and build out some of these sub
[01:55] (115.84s)
aents directly in our Cloud Code
[01:57] (117.68s)
interface. So, we're going to pause here
[01:59] (119.04s)
and come back as soon as it's finished.
[02:01] (121.36s)
All right, so we're finished now and we
[02:02] (122.96s)
have nine sub aents that we've built.
[02:05] (125.28s)
So, I've prompted Claude to go ahead and
[02:07] (127.84s)
create markdown files. Each of these
[02:09] (129.76s)
stored as individual artifacts that we
[02:12] (132.00s)
can use. So, as you can see, we have all
[02:15] (135.20s)
nine different personas that are
[02:16] (136.64s)
available to us. So, we're only going to
[02:18] (138.40s)
use one here. Let's look at the
[02:19] (139.84s)
architect sub agent. And you can see
[02:21] (141.68s)
that we can go ahead here and copy this
[02:23] (143.52s)
directly into our clipboard. And it goes
[02:26] (146.56s)
into all the key information that I was
[02:28] (148.96s)
able to discover from looking at
[02:30] (150.48s)
Superclaude in the relevant
[02:31] (151.84s)
documentation. So, what we'll do next is
[02:35] (155.04s)
we're going to go ahead here over into
[02:36] (156.80s)
Claude Code. So to create a new agent,
[02:39] (159.60s)
you're going to hit the / agent command
[02:42] (162.00s)
and then we're going to click create new
[02:43] (163.76s)
agent. We're going to make this a
[02:45] (165.76s)
personal agent so we can use it in all
[02:47] (167.68s)
of our projects that are available to
[02:49] (169.44s)
us. So we'll click on that and we're
[02:51] (171.52s)
going to follow the documentation which
[02:53] (173.28s)
is the recommended to generate with
[02:55] (175.12s)
Claude. Once we go through, we're going
[02:57] (177.52s)
to go ahead here and we're going to
[02:58] (178.96s)
paste in our system prompt for our
[03:02] (182.56s)
architect sub agent. And we're going to
[03:05] (185.04s)
hit enter. And what this is going to do
[03:07] (187.12s)
is it's going to go ahead and generate
[03:08] (188.72s)
our agent configuration. So we'll come
[03:11] (191.04s)
back here as soon as it's finished. All
[03:12] (192.64s)
right. So now the configuration has been
[03:14] (194.80s)
created and we're at the step where we
[03:16] (196.40s)
can give it tools. So for this one we're
[03:18] (198.08s)
going to give it all tools just for the
[03:19] (199.60s)
example. Maybe for an architect agent we
[03:21] (201.84s)
want to just have it as read only. So
[03:23] (203.60s)
you're only using sequential thinking
[03:25] (205.44s)
and context 7 for information gathering
[03:28] (208.32s)
for the knowledge bases. But for this
[03:30] (210.16s)
we'll go ahead and hit all tools here.
[03:32] (212.08s)
So, we'll go ahead and make sure that
[03:33] (213.60s)
that's selected and we'll click on
[03:36] (216.40s)
continue. And then you can change your
[03:38] (218.40s)
background. So, for this, let's just say
[03:40] (220.40s)
that we're going to use the system
[03:41] (221.92s)
architect is going to be a blue agent.
[03:43] (223.92s)
All right. And then we're going to get
[03:45] (225.28s)
to our final steps. In which case, we're
[03:47] (227.36s)
going to go ahead here and it has a name
[03:49] (229.28s)
of system agent and it's been created.
[03:51] (231.68s)
So, now we have the ability to use that
[03:54] (234.16s)
in our codebase. So, what we're going to
[03:56] (236.88s)
go ahead and do is I'm going to start
[03:58] (238.56s)
going through and set up the rest of
[03:59] (239.92s)
these other eight agents and I'll do
[04:01] (241.84s)
another post here in the future where we
[04:03] (243.68s)
talk about some of the practical use
[04:05] (245.28s)
cases that we can use these sub agents
[04:07] (247.04s)
for. And what is super cool when we were
[04:09] (249.44s)
actually looking through some of the
[04:10] (250.80s)
post here from what Sid posted on his X
[04:13] (253.92s)
feed, it does look like it's going to
[04:15] (255.76s)
use the base model that you have. So,
[04:17] (257.36s)
you're going to have access to both Opus
[04:19] (259.68s)
and Sonnet as long as you have that as
[04:21] (261.92s)
your default model. it's not going to be
[04:23] (263.76s)
utilizing the haiku models for
[04:25] (265.28s)
execution. So, I hope this is super
[04:27] (267.28s)
helpful and I'm I'm looking to see in
[04:29] (269.04s)
the comments of any other use cases that
[04:31] (271.20s)
you guys are finding for different sub
[04:32] (272.80s)
agents.