You're probably wasting hours in chat

GBT and Claude running the same manual

loop over and over again. You start one

chat to do research and find the facts

and then you take the facts and copy

paste them into a brand new chat and

then you spend the next few minutes to

hours going back and forth and iterating

until you nudge it in the right

direction. There must be a better way,

right? Absolutely. There's a way for you

to create your own AI assembly line of

agents that go and do the work for you,

doing drafting, researching, and even

editing, coming back to you with the

final result. And if you know the right

steps to implement, then you can do this

with zero technical background and zero

coding at all, just using natural

language to create agents that execute

tasks for you. So, in this video, I'm

going to show you exactly how you can do

that in something like Clawude Code. So,

if you watch till the end, then you'll

be able to create your own mini AI

workforce that can execute tasks for you

and more importantly make you up to 10

times more productive. If that sounds

interesting, then let's dive in. So, if

we hop into Cloud Code, I'm going to

show you my workspace and show you

exactly how this works and more

importantly, I'm going to walk you

through how you can do it yourself and

use a prompt I put together to make this

as seamless as possible. A lot of people

use agents in cloud code for development

and writing code. And as someone who is

a developer, I will use them sparingly

depending on the task. But what I

noticed is a lot of people are not

talking about the fact that you can use

the same firepower that you get in an

editor like cloud code in combination

with their sub agent feature to execute

all kinds of normal language-based

tasks. So if we take a look right here,

we have three agents. We have the

research analyst, we have the creative

copywriter, and finally the senior

editor. And all of these are going to be

used in this project which in this case

was meant to create a series of slides

where you do the research for the topic

create the copy the actual slide design

and come back with a series of assets.

So instead of reading the prompt here it

doesn't look too easy on the eyes. We

can go into something like Google Doc

and you'll see the presentation

basically says create content for a 25

slide presentation titled the state of

AI quarter 4 2025 for a non-technical

business audience. And here we walk

through exactly what the workflow should

look like and we specify exactly where

each agent we created should be used. So

for anything research related obviously

the research analyst is meant to look

for the significant AI breakthroughs

from the past year look at current

market trends and using surprising

statistics and it can use cloud code's

ability to also go and scour the web.

Now you can supercharge this by adding

even more things like MCP servers to

make it that much more potent in its

research ability but you can use the

vanilla out of the box. And then we have

for content creation the creative

copywriter and all of these are just a

series of prompts. There's no code.

There's no fancy UI you have to

navigate. And in this case, it just

focuses on creating the flow and

structure of the copy that's going to

appear on the slides themselves. And the

main goal of the senior editor agent is

to make sure that your copy for your

slides has ultimate clarity, maximum

impact, and more importantly, make sure

it actually lands for the target

audience. And then for the output

requirements, all we ask is for a final

output of the slide content, the

structure, and then I ask for this part

here that's called Askiard. An Askiard

is basically creating a mini diagram of

positioning and visualizing what the

text would look like on the slide. And

you can go the next step further where

you could ask it to draft a design of

the layout of the slide if you're trying

to get fancy with it. But the core

deliverable are 25 slides formatted

according to the specified structure

ready for presentation. So if we go back

into cloud code, you'll see the magic

here where now all of our agents get

spun up and these are the ones that

already created ahead of time which

again I'll show you right now. You have

the research analyst, the creative

copywriter, and the senior editor.

They're all invoked and behind the

scenes, they took around 10 minutes to

go all execute their subtasks, then

baton pass it to the next one. And

what's cool is depending on the set of

instructions that you give Claude code,

you can make them go back and forth. You

can do multiple passes between the

research analyst and the creative

copywriter. So you have a lot more

granular control than a lot of these

tools that look really fancy but behind

the scenes are very rigid in the way

they allow you to create and use agentic

structures. So you'll see here after the

creative copywriter is done drafting the

presentation and narrative, the senior

editor gets to work, does a lot of the

reading from the work that was done by

the copywriter and then basically this

agent takes over until we get to the

very end where it creates a series of

final slides in a directory that's going

to be right here. When we click on

state-ofthe-art or state of AI rather

presentation, you'll see all of the

agent deliverables including the final

slides and we can click on any one of

them. So let's say data privacy and we

just zoom this in a little bit. It

creates a really detailed markdown file

that walks through what the title should

be, example of on-screen text, speaker

notes for you, the layout suggestions in

terms of where things should be

arranged, database for foundation,

document law for compliance, handshake

for consent. So you can make it go a lot

deeper and again you could go the

natural next step where you hook up

something like an API or an MCP server

to go and actually create this in

something like the gamma API that's good

at creating AI slides. But the goal of

this is just to show you what's possible

to break any limiting beliefs if you're

non-technical or technical that you can

use things like this for all kinds of

use cases outside of just vibe coding.

And one really cool thing that a lot of

these tools like cla and chatt don't

show you is all the rough work that goes

into creating the final deliverable. So

all the assets here are created. So the

draft created by the copywriter, the

research created by the research

assistant, you can see exactly what they

went through and what they looked

through. Whereas on something like

Claude, all you can usually see is some

form of citation of where the draft was

inspired by. So again, this is about

giving you granular control. And now you

might be looking at this hopefully

salivating and saying, "This looks cool,

looks very powerful, but unfortunately I

absolutely hate working in a terminal."

Do I have alternatives? You do. You can

use something like Claudia, not

affiliated, it's free. You can download

it on your computer. It basically gives

Claude code a front end where you can

interact with it just like you would

chatbt. You can click on agents. You can

set them up here like in natural

language. You can have a conversation,

see multiple sessions that are running

and have a lot of granular control as

well as insight on being able to add

MCPs, seeing usage in terms of how much

you're using your API keys. You can see

here I'll be bankrupt shortly. But if

you want an alternative where you can

harness the same power, but you don't

have to stare at this, then that's your

alternative. So, now that I've shown you

what is possible, let's actually set up

a few agents of our own. And let me show

you the cheat code prompt that I put

together that you'll be able to use by

the end of this video to be able to spin

up the definition and instructions that

you can get started with. So, right here

in cloud code, all I have to do is do

slash agents and then when you click on

enter, you'll see that I have a series

of lingering agents. We have our best

friends here we just saw and then we can

just hover here with our arrow key click

on create new agent and then you can

choose either project or personal. If

it's project that means for this

particular project in this folder we'll

have these agents assigned. If you

select personal then any agent that you

set up will be accessible in any project

from here on out. So in my case I'll go

to project and what's cool is you don't

have to necessarily even use my prompt

to generate a starter prompt. You can

use claw to tell it in plain English

what you're looking for and it can spin

up instructions of its own. And I'm

naturally very lazy. So what I like to

do is two options. One, you can go to

this free website. It's called sub

aagents.cc.

And what it has is a series of prompts.

If you click on view all, a series of

different agent prompts optimized for

cloud code. So, if we go to something

like the CEO quality controller agent

and click on this card, it will show us

this prompt that's really well put

together that we can click on copy,

paste it into a language model or cloudi

or chatbt to have us better enhance it

or use it and tailor it for our use

case. In our case though, I already

created this mega prompt and this is the

claude code assembly line prompt that

will essentially allow you just at the

very bottom right here to put an example

of what you're trying to automate or

what you're trying to create. So in our

case, it was a slide deck. You could

also say I'm trying to create a content

calendar for an upcoming workshop where

I'm going to teach XYZ audience about

this thing in AI. And once you fill it

out here, then you'll be good to go.

Now, for the rest of the prompt,

obviously I won't go through it in

depth, but basically just says you must

generate the output in the following

two-part structure. Number one is the

title of the agent, the description of

the agent, the agents rules, when it

should be referred to. But wait, there's

more. After it actually comes out with

all those assets, it's useful to also

have your first starter prompt. So

notice when we first started the video,

I walked through my instructions to

create that slide deck. Basically

calling on the agents like Santa would

call on Reindeer saying, "Bliten, you do

this, then Rudolph, you do that." We do

the exact same thing with this starter

prompt. So I will just copy this as is.

And you can go to any language model of

choice. In this case, I'm just going to

use Gemini. I'm going to paste it in.

And then I'm going to basically replace

this insert your own task. And we'll

just say something like, I want to be

able to create a content calendar for a

3-day workshop where I am teaching

people in the real estate industry how

to properly leverage practical AI.

Okay. So then I will let that fly and

then we'll send that over. And look at

this. We have a series of agents it came

up with. It decided that we have one,

two, I think, yeah, two agents here as

well as an instruction prompt that we

can execute with. So, I can take this

real estate strategist, copy it over, we

can paste it into cloud code right here,

and then it asks for the system prompt.

And then, lucky for us, we have this

prompt already waiting for us, ready to

copy paste. Obviously, go through it,

make sure it meets your requirements,

what you're looking for, maybe take it

into a Google doc or a sheet before you

actually paste it. But let's assume

we're happy with it. We'll take it,

copy, paste right here. We'll click on

enter. And then it just asks us when

should this agent be invoked. And this

is really important because it gives

claude code the framework or the mind

map of knowing which employee to invoke

for which task. So in this case I

already got you covered. So we have the

description here. Use this agent to

identify high impact practical AI use

cases and then it walks through exam an

example. You can add this example as

well to context. I think usually that

just a normal sentence suffices. So, I

will paste this in. And then you can

tell it I want it to be attached to no

tools, these tools, these MCP tools. And

this is really where you can make things

a lot more potent and make them really

powerful. But for now, we're going to

stick to the basics of just clicking on

continue. And then you basically tell it

which model it should use. Now, I will

recommend, especially if you don't want

to spend $200 on a max plan, don't use

Opus. Ideally use sonnet or you can

select this thing that's called inherit

from parent. Meaning if you in your

session decide to choose opus then it

will use opus. If you use sonnet then

you use sonnet. So up to you which one

you choose. Hi coup I find not as

intelligent as you need it to be. So I

would just do inherit from parent and

then you can pick a color for it. And

this will tell you and denote when this

agent's actually working. So we'll click

on purple. Okay. Then we'll click on

enter. And then we'll click on create

new agent one more time. We'll do

project and then manual configuration.

Then we can go back paste the exact same

thing. So in this case down below we

have the instructional designer. We'll

copy that over right here. We'll take

the system prompt and you can see how

buttery this process is if you have the

right prompt to lead you on. And then we

take the description. Boom.

Okay. Paste that in. And now click on

continue. Inherit from parent. And then

let's do blue.

Then when we click on enter and click on

escape. Okay, we'll be ready to go. So

we have this prompt right below and it

walks through an example request where

you basically tell it when to invoke the

agents even though it has its own

reference material. But I just find that

by compounding those instructions and

giving it more of a nudge, it does a

better job of using them at the right

time. So, we'll tick on copy. And then

you can see right here, agent changes.

We now have two brand new agents. We'll

paste this set of instructions. There we

go. And then we'll paste it on. I'm not

going to actually have this run. This

will probably take anywhere from 5 to 20

minutes depending on the task. But the

assets will look very similar to what

you saw before. And you can see right

here right away, the real estate AI

strategist is on the case. And the

beauty of using agents in cloud code is

that each one technically gets a blank

slate of context window where it's

focused on that particular task and it's

not really muddied by everything that

happened before it's invoked. So that's

a very useful tip to use. So hopefully

this breaks a bunch of limiting beliefs

that whether you're technical or

non-technical, there is a lot of

firepower on the other side of being

able to use these tools to do day-to-day

tasks that would otherwise take you

hours or multiple chain prompt steps in

something like chatbt. And with that, if

you enjoyed this and this was helpful

for you, I'm going to make the first

prompt I showed you available in the

second link in the description below.

And if you love content like this and

you want to go even harder and really

see what you can do with cloud code,

like connecting MCP servers, building

full web apps, doing even more

procedural tasks, automating custom GPTs

and anything like custom GBTs, then not

only do I have a series of other agent

prompts in my exclusive community, but I

also have a whole series that I've built

that I'm about to finish around 20

different modules from going from zero

to hero using this technology, even if

you're not technical, to become that

much more productive. I'll see you the

next one.