The AI Coding Workflow Most Developers Are Missing.

0:00Lots of developers right now are making

0:01the same mistake. They are using one

0:03single AI agent to do all of their work,

0:05writing the code, testing it, reviewing

0:07it, deploying it, all one agent. But,

0:09what if instead you could spin up your

0:10own specialized sub-agents and run them

0:12all in parallel directly from anywhere,

0:14like your terminal? And then, once those

0:16agents are set up, wrap them in

0:17repeatable workflows you can trigger

0:19with a single command. That way, your

0:21whole team can run the same parallel

0:22pipeline on demand. But, today I'm going

0:24to show you how you can do it on a tool

0:25called Vibe from the guys over at

0:27Maestro, who have also partnered with

0:28this video. And a couple of weeks ago,

0:30they just dropped their latest flagship

0:32model, Medium 3.5, and it's now the new

0:34default model inside of Vibe, their

0:36agentic coding tool that we're going to

0:38be using today. It replaces Dev Stroll

0:402, which they actually only shipped just

0:41a few months back. And since their old

0:43models, every iteration has gotten far,

0:45far better. Now, the first thing to note

0:47is the entire model can actually be run

0:49locally. It's a 128 billion parameter

0:52dense model, which means you're going to

0:53need some seriously powerful GPUs to go

0:55ahead and run that thing, but it is

0:57completely doable. And that's really

0:58important if you're dealing with

0:59something private or sensitive. For

1:01example, if you're dealing with any kind

1:02of legal issues or any kind of contracts

1:04that you don't want to send up to the

1:05cloud, this could be a very genuine

1:07solution. It has a 256K context window,

1:10which means it's actually a great

1:12candidate for using something like

1:13sub-agents. And that the entire model

1:15was actually trained to be their best

1:16coding model. Yeah, scoring 77.6 on SWE

1:20bench verified scores. Given that this

1:22is significantly cheaper than some of

1:24the frontier models out there currently.

1:25And it's crazy fast. Our official

1:27analysis clocks it at around 170 tokens

1:30per second, which is well above average

1:32for non-reasoning models in its class.

1:33And something cool that you might care

1:35about, Medium 3.5 is actually open

1:37weights, which means that we you can

1:38actually see the entire code base and

1:40the weights that they use under the

1:41hood. Future Sunny here, a quick note

1:43before we start. Now, a few times in

1:45this video, I say Maestro, when it's

1:47actually pronounced Mistral. So, don't

1:49be like me and pronounce it correctly.

1:50Now, without further ado, let's get into

1:52building some custom agents. First thing

1:54that you want to do is actually head

1:55over to the first link in the

1:56description. By going to that link, you

1:58can actually create a free My Show

2:00account. So, you land over at this page.

2:02Now, I've already created an account.

2:03What you need to go ahead and do is pick

2:04your sign-in method, log in, and then

2:06you'll head over to the dashboard. Now,

2:07once you're in the dashboard, we need to

2:09install the Vibe CLI. So, to get started

2:12with that, it's pretty simple. You guys

2:13can see here, we've just got this

2:14command. You can go ahead and copy it,

2:16head over to our terminal, and paste it

2:18in. I've already installed this, so in

2:19this case, it just updated it for me.

2:21But now, you can see that you can run a

2:22vibe with literally the vibe keyword,

2:25okay? Now, I'm going to go ahead and

2:27actually go into a previous build that I

2:29did. So, this was actually a recent

2:32build that I did on my last live stream,

2:34so you can feel free to check that. It

2:35was around 10 days ago from the time of

2:36this recording. But, I'm going to go

2:38ahead and actually vibe inside that

2:40directory. So, I'm going to go do vibe

2:41and forward dot. And you don't even need

2:43to do that, you can just write vibe. And

2:45in this case, it will ask, "Do you want

2:46to trust this folder?" So, we're going

2:47to go ahead and move over to the left

2:49and say, "Yes." And then, it kicks off

2:51things. Now, if it was your first time

2:53actually launching the Vibe CLI, it

2:55would prompt you to log in. Typically,

2:56it would open up the web page, and you

2:58can just authenticate. Really easy to do

2:59that. But once you're in it, you'll go

3:01ahead and see that we are on My Show

3:03medium 3.5, which is their latest

3:05flagship model. Now, we can go ahead and

3:08get used to a couple of useful commands,

3:10I guess, by doing forward slash help.

3:12So, by running that command, you can see

3:13most of the useful things that you're

3:15going to probably need to ever touch,

3:16right? The main one is really forward

3:18slash model. If you want to change

3:19things, your thinking level as well. And

3:21also, things like clearing your context

3:23window. Okay, so we've gone ahead and

3:24cleared the terminal, and I want you to

3:26pay attention to a couple of key

3:27details. Firstly, we've got the token

3:29used down

3:32in some top-tier CLIs. For example, MCP

3:34support, skills, and so forth. And then,

3:36the main thing really is is that before

3:38you start chatting with it, you notice

3:39it's in default mode. I want you to get

3:41used to if you do shift tab, and this

3:44become a standard now across these CLIs,

3:46where you can shift between modes. So,

3:48as you can see, I'm in plan mode. Shift

3:50tab becomes accept edits, and the same

3:52for auto approve, okay? But, typically,

3:54there's not a tutorial on how to use a

3:55CLI like this. The main thing that I

3:57want to showcase today is a sub-agent.

3:59So, before we can actually do anything

4:00meaningful, we need to get the app up

4:02and running, okay? So, I want to go

4:03ahead and actually spin up the app

4:05first. So, I'm going to go into the

4:06directory, and then I'm simply just

4:08going to go ahead and make sure I've got

4:09everything installed, and then I'm going

4:11to go ahead and run it. So, PM PM dev,

4:13and then this will should be able to run

4:15on localhost 3000. So, let's go ahead

4:18and pull that up right now. And as you

4:19can see, we've got proper BNB, Airbnb

4:21style clone. And if you're interested in

4:23learning how to build this, you can

4:24check out my live stream, as I

4:25mentioned, okay? Now, this app in

4:26particular would benefit a ton from

4:28sub-agents. Why exactly? Because we

4:31actually built it on a live stream,

4:32which means I was more faster than usual

4:34to get things through the door, which

4:36means there's probably areas which can

4:37be improved, okay? So, a couple of

4:39things that we could introduce here will

4:41involve, as we mentioned previously,

4:43something like a coding standard agent.

4:45So, in this case, something like a code

4:46review agent, and also something like a

4:48scalability agent. So, in this case, it

4:50works for me right now, but what if we

4:52had, you know, say 10,000 users right

4:55now? Would it scale well based on the

4:57tech stack? And also, something like a

4:59security agent, right? Really depends on

5:01what your need is, okay? So, we're going

5:02to go ahead and show you today how to go

5:04ahead and get up and running. So, we're

5:05going to leave that running on the side,

5:07and then we're going to jump into this.

5:08So, if we simply went ahead and typed

5:10in, for example, what's the tech stack

5:11of this build? And I don't actually use

5:13typing a lot of these days. I actually

5:15use something called Super Whisper. So,

5:16in this case, I'm going to go ahead and

5:17use that right now. What's the tech

5:19stack of this build?

5:21And if you're wondering while it's

5:22generating, you can use Sunny 25 over

5:25Super Whisper, and you get a nice little

5:26discount. All right, and in this case,

5:27you can see the app It's actually a

5:29very, very fast model, all right? So, I

5:31found that it's actually pretty rapid

5:33every time that I've gone ahead and used

5:34it.

5:35Uh and as you can see, we've got a nice

5:36little breakdown of all of the tech

5:38stack that's been used here, okay? So,

5:40in this case, this is a lot to kind of

5:41cover, you know, maybe we don't want to

5:43have our single agent cover this, or we

5:45just want the same approach every single

5:47time. A perfect use case for sub agents.

5:50So, we're going to take a look at the

5:50documentation firstly. Now, obviously,

5:53you can play around in the Maestro

5:55dashboard yourself, and I would pay

5:57attention to even the connectors here,

5:59which we'll take a look at in just a

6:01second. But, these connectors are

6:02effectively like plug-in elements. So,

6:04basically, we can go ahead and toggle

6:06things like linear, Stripe, and any

6:08other useful connector that we find that

6:10we need. For example, you can go to and

6:12check out the directory, and that will

6:13allow our AI to basically get powered up

6:15and have a native connection into that

6:18platform. But, first off, more

6:19importantly, we need to get to the

6:21documentation. So, we're going to go

6:22down here to help and resources,

6:24documentation. Now, the thing that I

6:26find easiest is if you ever lose your

6:28way and you want to find things really

6:29easily, just head over to the home page,

6:31maestro.ai, and then you can go ahead

6:33and you have a few options at the top.

6:34Now, again, they have the install

6:36command literally at the top, very very

6:37simple. But, we're going to click on

6:38this documentation right here. All

6:40right. Now, the most important part that

6:41you want to kind of pay attention to

6:43here is Maestro Vibe, okay? So, like I

6:45said, they have studio and the chat as

6:46well, you can check those out. But,

6:47we're going to cover mainly Maestro Vibe

6:49today. Now, the one that we're

6:50interested in is actually going to be

6:53agents and skills. So, here we can

6:55pretty much get a breakdown of how

6:57agents work. Now, they do actually come

6:58with five built-in agents, okay?

7:01Default, plan, accept edits, auto

7:03approve, and explore. Now, the first

7:06four, you'll notice we actually were

7:07able to, you know, change between inside

7:09the CLI earlier. So, remember when I was

7:11doing it earlier, where I went ahead and

7:13did shift tab, these are actually

7:15different agents that effectively will

7:17run, right? We have a plan agent, an

7:19accept

7:20accept edits agent, an auto approve

7:22agent, and a default. And you'll notice

7:23how each one also has a different color,

7:25right? And that's important for later on

7:27as well. And then, we have sub agents,

7:28right? So, in this case, an explore.

7:30Now, what makes an agent special? What

7:32makes it separate from another agent and

7:34so forth, right? Well, we can actually

7:35create these custom agents by creating a

7:38TOML file inside of the dot vibe {slash}

7:41agents folder, okay? Now, this is where

7:43we can basically go ahead and break it

7:44down. So, we've got the display name is

7:46the name of our agent. So, in this case,

7:48we can have one called like maybe a code

7:49reviewer, security agent, for example,

7:51deployment agent, scalability agent,

7:53whatever you really want. The

7:54description is the agent's job,

7:57effectively. And then we have safety.

7:59Now, this doesn't actually change

8:01anything in terms of functionality-wise,

8:03but safe, neutral, destructive, and yolo

8:05also are going to change the border

8:07color. So, in this case, you can see

8:08that actually changes the border color.

8:10So, that for example, you've got

8:12something which looks relatively safe,

8:14and then something which as an it gets

8:16more and more permission, you can go

8:17ahead and change it accordingly. Okay?

8:19So, that's what the safety does. And

8:21auto approve is similar to how we have,

8:23for example, auto accept edits, those

8:25different modes. And then this is the

8:27most important one is enabled tools.

8:30Okay? So, the ability to read file,

8:32grep, and so forth. And why is this so

8:33important? Because let's say, for

8:35example, we have a code review agent.

8:37The job of that code review agent should

8:39only be to review the code. Maybe we

8:42don't want that agent to actually change

8:44code or for whatever reason push code

8:47onto GitHub and or anything else for

8:49that matter. We just want it to have

8:51read access, so it can review the code.

8:53All right? So, that way we can safely

8:54assume that when it was running, it's

8:56not going to do anything that it

8:57shouldn't be doing. This is where we can

8:59go ahead and give that permission scope.

9:01So, what I want you to actually go ahead

9:02and do is in this case, where the

9:03documentation is, so in this case the

9:05sub-agents, this is more of a habit that

9:07I've come to form which I find works

9:09really well with AI tools, right?

9:10Regardless if it even has a skill to go

9:13ahead and use its own documentation, I

9:15still do this little trick. And

9:17basically what I'll do is I'll copy the

9:19link to the page. Even better, I will

9:20copy the actual section link, right?

9:23Then I will go back over, I'll paste it

9:25in, and then I'll start simply adding as

9:27much context as I can. So, in this case,

9:29this is number one. I've actually gone

9:31ahead and created a a really nice prompt

9:34here for this. So, I'm I'm to go ahead

9:35and pop that in right now as well. So,

9:37where we go ahead and say create a sub

9:38agent called scalability reviewer. It

9:40should analyze the code base

9:41specifically for scalability

9:42bottlenecks, N+1 queries, unbounded

9:44loops, missing indexes, blocking IO,

9:47memory leaks, and so forth, right? And

9:49then it should be read only, give it

9:50read file and grep only, no bash, no

9:52file rights, set the agent type to sub

9:54agent, and safety is safe. Put it in

9:57vibe agents, okay? So, in this case,

9:59I've been pretty explicit about it. Do

10:01you need to be that explicit? No, right?

10:03But would it help your agent from, you

10:04know, losing name, maybe going off

10:06track? Yeah, it can help prevent that,

10:08right? Because regardless of which LLM

10:10you're using, that's a possibility. So,

10:11I'll typically go ahead and paste that

10:13in, and then I'll go ahead and execute

10:14it. So, review the command. In this

10:15case, I'm going to go ahead and say

10:16always allow. And permission for the

10:19read file tool, we're going to always

10:20allow that one as well. In this case,

10:21we're going to first create our

10:22scalability reviewer. And as you can

10:24see, it's going to go ahead and try to

10:26write the new agent. So, it's trying to

10:28write into vibe agents, and it's going

10:30to create scalability reviewer with the

10:32instructions that we set before, with

10:34the safe Right? And this reason why we

10:36want to give it the safe color is cuz

10:37it's only going to have read file, which

10:39is pretty safe, right? And the agent

10:41type is sub agent, cool. So, we're going

10:42to say

10:43allow for the remainder of the session,

10:45and it's going to go ahead and create

10:46it. And there we have it. You see, it's

10:48created the agent, sub agent is ready,

10:49use it with the task tool. So, in this

10:51case, you can use the task tool to go

10:52ahead and call the agent, okay? So,

10:54that's pretty awesome. So, we have our

10:56scalability reviewer. And then if you

10:57want to go ahead and get into things a

10:59bit more, you can go ahead and ask, for

11:00example, what enabled tools do we have,

11:02right? So, in this case, I would go and

11:03say something like what enabled tools do

11:06we have for future sub agents that we

11:08might want to create.

11:11And then we can start diving into things

11:12a bit more. So, in this case, we can go

11:14ahead and see, these are the available

11:16tools that we can actually select from.

11:17So, we've got read file, grep, bash,

11:19write file, search replace, web search,

11:22web fetch, ask user question, to do,

11:24task, and a skill, okay? So, in this

11:26case, this is pretty handy for us

11:28because now we can go ahead and derive

11:30our next agent, okay? So, given this

11:32information, we want to go ahead and

11:34create a security agent next. So, this

11:36is going to be a sub agent, give it the

11:38relevant permissions that are

11:40appropriate for a sub agent, and then

11:41you can see it's now going to go ahead

11:43and generate. In this case, we've got

11:45our plan here, create a security sub

11:47agent, and he should scan code for

11:49vulnerabilities, and this is pretty good

11:50like SQL injection and so forth. Not

11:53modify files, okay? So, again, these are

11:55all like read-only agents, right? In

11:57this case, we should be putting in Vibe

11:58Agents Security Reviewer, and then like

12:00scans code base for security

12:01vulnerabilities, hardcoded secrets,

12:03injection risks, and outdated

12:04dependencies, read-only analysis. But

12:06this time, it gets a few more extra

12:08tools such as web search and web fetch,

12:11okay? So, in this case, yep, I'm happy

12:13with that. Switch mode, and then go

12:15ahead and carry on, okay? So, in this

12:17case, you can see it's going to go ahead

12:18and execute, and even if it does run

12:20into a hiccup, it can figure it out, get

12:22past that, and there we have it. We have

12:24our security viewer. So, now we have two

12:26sub agents, okay? We have our security

12:28reviewer, and we have our scalability

12:30agent. I guess the final one that would

12:32make sense is like a standards enforcer

12:35agent, someone who can go ahead and

12:36check our code base against things like

12:38the best practices, making sure that

12:40we've got the right naming conventions,

12:42consistent, you know, patterns across

12:44the code base and so forth. So, in this

12:45case, I'm going to go ahead and say,

12:46"Create a sub agent called standards

12:49enforcer. It should check the code base

12:51against typical coding best practices,

12:54things like naming conventions, function

12:56length, making sure that we don't have

12:58nested components, for example." And

13:00also things like checking for the any

13:02type in TypeScript, we should never

13:04allow that. So, these are all things

13:06that I would want to check with this sub

13:08agent. All right, so kind of a quick

13:09example, okay? So, another one. And in

13:11this case, I would go ahead and actually

13:13just say create another sub agent,

13:15right? So, obviously, any help we can

13:16give would always help us out. And this

13:18time, I'm going to leave it on accept

13:19edits mode. So, as you can see, it jumps

13:21straight through, and it was a lot

13:22quicker at doing that because I had

13:24accept edits already on, and then it

13:25jumps straight into adding it into Vibe

13:28agents. Now we have our third agent,

13:29standards enforcer. So in this case,

13:31this one enforces coding best practices,

13:33naming conventions, function lengths, no

13:34nested components, no TypeScript. Uh and

13:36it's cut that bit off by

13:38assuming it's in there, right? So we can

13:40check that one. If you really want to

13:41check, you can just go to that file and

13:43have a look. But in this case, read file

13:45and grep. Okay? Checks it will perform,

13:47TypeScript any

13:49any type usage, naming conventions, and

13:50so forth. And obviously, you can expand

13:52on these as much as you want. In this

13:53case, it's going to be enough for us to

13:55just do a demo. Okay. So now, imagine

13:57you're coding with your agents, you

13:59know, you can go ahead and start a new

14:00session now if you wanted to. Really

14:02doesn't matter. You can go ahead and

14:03have, you know, five sessions up and

14:05running. But let's assume I've added in

14:07a new feature, right? So I've come to

14:09the end of my dev cycle, and let's say

14:11I've, you know, I've built this page out

14:12now. And then I want to run an entire

14:14check, right? How do I actually execute

14:17and run one of my sub agents? Well, it's

14:19actually simple. We can actually go

14:20ahead and ask our main agent to go ahead

14:21and call it for us. And it's worth

14:23mentioning that with sub agents, you

14:25don't actually get to see the

14:26conversation of the sub agent. The sub

14:28agent, effectively, think of it as a

14:30secret ninja, kind of sneaks away, does

14:32some work, and comes back to the main

14:33agent and gives back a response, okay?

14:36So in this case, I want to say something

14:37like, "Using the sub agents that we have

14:40created, for example, the security

14:43agent, the scalability agent, and the

14:46coding standards agent, run them all in

14:49parallel and check our entire code base

14:51for fixes that we need to implement."

14:54Okay? And then we're going to go ahead

14:56and click on okay. And what I want to

14:57see here is that it will go ahead and

14:59actually spin them up in parallel. So

15:01this is what I love here. You see this?

15:02It's actually kicking off three parallel

15:05agents, okay? And in this case, what I'm

15:07going to do, always allow, and I'm going

15:09to actually going to change our mode

15:10here to auto approve, okay? So this is

15:13what I love here. It's actually running

15:14all three of these in parallel. So these

15:17are three sub agents now that have fired

15:19off. And as you can see here, it's

15:20running the sub agent. But most

15:22importantly, you can see about

15:23represented by these little dots. Okay,

15:25so we have 1 2 3 and all of those are

15:27going to go ahead and basically start

15:29scanning the code base and you can see

15:30it's already running its individual

15:32commands here per sub agent. So we're

15:34going to give that a moment. We'll be

15:36back in a sec and we'll see what it did.

15:37Okay, so you as you can see we are three

15:40sub agents just completed and then they

15:42will report back to our main agent who

15:44then prepares a report back to us. And

15:46as you can see this is really really

15:48nice, right? But we've got a really

15:50really nice kind of report that's been

15:51generated and it's giving us a

15:52recommended action plan. So this is a

15:54furiously good breakdown, right? Now

15:56imagine, I want you to frame this

15:57scenario. Every single time a member of

15:59your dev team finishes a feature,

16:02imagine if we could spin up these three

16:03sub agents the same way every single

16:05time and it could just effortlessly

16:07happen, right? We don't we don't have to

16:09get the prompt right every single time

16:11and make sure that it kind of comes up

16:13because as you can see it provides a

16:15clear amount of value, right? So as we

16:17go over here we can have a look cuz

16:18there's quite a lot of issues with fun,

16:20right? Security risks, scalability

16:22risks, coding standard issues for

16:24example at empty prettier I I see and

16:26again, are these super important? No,

16:28but in this case if we had a look at

16:29some of the uh it actually started

16:31ranking them for us which is very handy.

16:33As you can see here like critical,

16:34scalability and so forth and then it

16:36goes ahead and figure out a plan for us,

16:38right? Based on the source severity,

16:40right? Emergency fixes today, critical

16:42code fixes this week and so forth based

16:44on the priority, right? So in this case

16:46you could go ahead and basically reply

16:48to this and say would you like to

16:49implement

16:50or critical detail PR's which category

16:52and so forth. You can go ahead and reply

16:53right with the option that you would

16:54want. But again, we could do that and it

16:57would go ahead and execute, but I'm

16:58going to actually cancel this. I want to

17:00instead show you how we can you know,

17:02repeatedly run this entire workflow

17:05every single time. So we already saw

17:06there how each agent can be responsible

17:08for its own actions. And the one thing I

17:11want you to realize is look how we only

17:13remained on 15% of 200,000 tokens,

17:16right? So even though we run all of

17:18those three sub agents, each one had its

17:21own isolated environment, and also each

17:23one was controlled with permission

17:25scope, so it could only access specific

17:27tools that we set, as well as each sub

17:29agent had its own context window. So,

17:32our main agent window here did not get

17:34bloated, okay? It just got a direct

17:37concise report from each agent, so that

17:40way our main agent can basically be

17:42quite efficient. is the pattern that we

17:44want to basically replicate. How do we

17:45do that? Well, when we do forward slash,

17:47what you'll see here is I've actually

17:49got things like these clerk that forward

17:50slash commands, right? And these are

17:51custom slash commands. You're probably

17:53wondering, how do we get these, right?

17:55So, if I wanted to do something like a

17:56forward slash review or a forward slash

17:58audit, right? And that audit would

18:00basically trigger off all three sub

18:02agents. How come we do that? Well, we

18:03can do that if we actually look at the

18:04documentation, this is actually from a

18:07skill, okay? So, if we see over here,

18:10Maestro's vibe skill system allows you

18:12to extend functionality through reusable

18:13components. Skills can add new tools,

18:15slash commands, and specialized

18:17behaviors, okay? So, in this case, we're

18:19going to go ahead and create a skill

18:22which will run those three sub agents,

18:25okay? So, I'm going to go ahead and, for

18:26example, copy this, go back over here,

18:29and I want to say, I want you to create

18:31a forward slash audit skill where

18:34whenever we run the audit skill, it

18:36basically carries out what we just

18:38executed right now. It should trigger

18:41the three sub agents, a scalability

18:43agent, a security agent, and a coding

18:46standards agent, and it should go ahead

18:48and present it just like we did right

18:50now.

18:51And then what I'm going to do is I'm

18:52going to switch this to a plan mode, and

18:54I'm going to run this, okay? And then

18:55we're going to create we're going to ask

18:57the agent to effectively create this for

18:58us, right? And again, is it going to be

19:00perfect every time? No. Is it going to

19:02get everything right the first time? Not

19:04all the way is the case, right? Again,

19:05AI is non-deterministic. If it goes off

19:08track here, I would recommend you go

19:09here, you just simply copy the link, you

19:12throw it over to your agent so you can

19:13get a bit more context and so forth.

19:14But, typically we can get to where we

19:16need to get to if we're in plan mode,

19:18okay? So, let's give this a second, come

19:21back in just a moment. Okay, so here we

19:22have a plan. Create a new skill called

19:24audit that when invoked by the skill

19:26tool triggers three sub agents, security

19:28review, scalability, and coding

19:29standards in parallel, presents a

19:30consolidated report. Current state,

19:32three sub agents already exist and

19:34produce detailed reports, right? We've

19:35got this, perfect. Implementation steps,

19:38step one, create the skill audit skill.

19:40There we go. Step two, skill content

19:42structure. And then you can go ahead and

19:43just make sure everything is obviously

19:44running. And even the consolidation of

19:46the report, right? That exact way that

19:48it's, you know, presented to you, you

19:50can go ahead and get that kind of dialed

19:52in at this point as well. Files to

19:53create, success criteria. So, in this

19:55case we're pretty happy with this. We're

19:56going to go ahead and auto approve. And

19:58while it's building this, I want to

19:59explain something. So, I typically refer

20:02to these things or this these kind of

20:04flows as workflows, okay? So, when I

20:07tend to basically find a way of working

20:10with AI of routines that I want to run

20:12consistently every single time, I will

20:14take that process, just like now when we

20:16run three sub agents, and I will wrap it

20:18inside of a workflow.

20:22And that typically is just a skill,

20:24right? So, what we do is we call it a

20:26workflow, but really it's effectively

20:28just a skill. And that skill allows us

20:30to call it every single time

20:32consistently. And that way we can go

20:34ahead and make sure that next time I

20:35call it it's going to be consistent as

20:37well as if a team member calls it, it's

20:39going to be consistent with them as

20:40well. Okay, so it's just finished and we

20:42can see it's gone ahead and created a

20:45comprehensive audit skill that instructs

20:46the agent to trigger three parallel sub

20:48agents, consolidate the results, and

20:50then provide the formatted output. And

20:52here you can see, to use a skill, invoke

20:54it with the skill name, and the agent

20:56will automatically launch all three in

20:57parallel and so forth, okay? So, this is

20:59perfect. I'm going to actually prove

21:01it's working really nicely by going

21:03ahead and actually exiting by doing and

21:05C. So, I can actually quit completely

21:07and then start a new session with Vibe.

21:09Just to prove that it's a totally new

21:11session and then I do forward slash and

21:13as you can see, audit. Look at that,

21:14guys. You can actually see comprehensive

21:16code base audit skill that runs

21:18security, scalability, and coding

21:19standards. Now, if we were to go ahead

21:21and say, for example, add a new feature,

21:23uh you know, you can go ahead and do

21:24that and then we simply do forward slash

21:26audit. And now, as you can see, it

21:29triggers that workflow. So, if we go

21:31ahead and let this run now, it's

21:33actually going to go ahead and run that

21:35entire workflow. And this is the really,

21:36really cool part where it all comes

21:37together. And look at this, I understand

21:39audit skill workflow ready to execute

21:41when you're when you request an audit,

21:43okay? So, in this case, I can say run

21:46the audit. And now, it should go ahead

21:49and kick off the three sub agents every

21:52single time. And there we have it. You

21:53can see it goes ahead and runs the audit

21:56across three sub agents, right? So,

21:59that's it. Perfect stuff, right? Now,

22:01obviously, this was a sort of a shallow

22:03example, having you know, three very

22:05kind of, you know, common things that

22:07you might want to go ahead and use a sub

22:08agent for, but you can obviously take

22:10this to the nth degree in terms of

22:12complexity that you wish, right? I

22:14actually use this flow in and out of

22:17every single project I do. Every single

22:19time I submit a PR, I always have a code

22:22review agent assess it. And basically,

22:24I've trained that code agent the exact

22:26way that I check for things so that way

22:28I can save myself time and I can get the

22:30agent to do it every single time, okay?

22:31So, we're going to go ahead and cut this

22:33one now. Of course, everything we did

22:34today was from the Vibe CLI, right? So,

22:36you can feel free to download it, try it

22:37out for yourself. However, it's worth

22:39mentioning as well that you can actually

22:40kickstart agents off and they're known

22:42as remote agents from the Let's Chat,

22:45right? So, you can actually see on side

22:46the screen right now, this is an example

22:48of the Let's Chat dashboard. You can

22:50actually get to this chat by heading

22:51over to chat.maestro.ai

22:54and then you can go ahead and see your

22:55chats on the side. Now, these chats you

22:57can actually go ahead and use the

22:58forward slash teleport command to go

22:59from your CLI to the Maestro Let's Chat

23:02dashboard as well, depending on if

23:04you've got everything connected and

23:06you're on the right plan, which I

23:07thought was pretty cool. And of course,

23:09as I mentioned before, it's pretty damn

23:12affordable, right? So, you can see here,

23:13the free plan is great to get started,

23:15but the pro plan, as you can see,

23:16they're quite competitive compared to

23:18the other frontiers out there. And if we

23:20go to the I'm a student, this is where

23:21things are going to be really good for

23:22you guys, especially if you're students

23:24out there. I know we've got a lot of

23:25students watching this channel. You guys

23:27can see if you can prove that you're a

23:29student, you can go ahead and actually

23:30get the entire pro plan effectively with

23:33the student discount at only $6 a month.

23:35So, this is incredible if you're a

23:37student and you want to go ahead and get

23:38set up too. And of course, you can go

23:40ahead and set up a team account if you

23:42like me and you have several users on

23:44your plan. Now, to get the full suite of

23:45everything that I've talked about today,

23:47you're going to need to be on the pro

23:48plan. So, go ahead and hit the link in

23:50the description to get a little discount

23:51off. You're absolutely welcome. I

23:53appreciate if you go through that link

23:54as well, because it allows me to

23:56continue making this content for free

23:58for you guys. So, that is hugely

23:59appreciated, as always. And there we

24:01have it, guys. We built three

24:03specialized sub agents, a scalability

24:05agent, a coding standards agent, and a

24:07testing agent. And each with its own

24:09isolated context, preventing our main

24:11session from blowing out. With the added

24:13bonus that each only gets the

24:14permissions that match the

24:15responsibility, which means less risk to

24:18an agent going rogue and breaking

24:19something that they shouldn't. Then you

24:21learned how to run them in parallel from

24:22a single prompt and then wrap that

24:24entire pipeline into a single command

24:26that you or your team members can call

24:28whenever you need to run that repeatable

24:29workflow. So, if you want to give this a

24:30try for yourself today, Vibe is part of

24:32the Let's Chat Pro and team plans. Go

24:34check it out by using the first link in

24:36the description. And remember, if you're

24:37a student, they have an awesome plan

24:39just for you guys, so worth checking

24:40out. And as always, guys, if you learned

24:42something new from this video, go ahead

24:43and smash the like button. It helps

24:44support this channel a ton. Don't forget

24:46to subscribe and hit the bell

24:47notification icon so you don't miss

24:49more. And as always, I'll catch you in

24:51the next one. Peace.

25:02>> I know

25:03how to love you.