How I Won Google's AI Agent Challenge in 5 Hours! [Free Code + 5 AI Dev Strategies]

Hey guys, I was just able to compete in

Google's second episode of the AI Agent

Bakeoff, which is a fivehour challenge

where we had to build a brand new

Agentic banking application in just

under 5 hours. And thanks to enough

caffeine and the right strategies, I was

able to win with my partner. So, in

today's video, I want to break down

those exact strategies I used into five

helpful tips that you can copy and steal

for your own workflows to build better

and faster agent workflows for your own

applications. Also, if you haven't had a

chance to watch the entire episode that

Google just produced where we're all

competing and building out the best

agents, I definitely recommend you

checking out that full video. I'll have

a link to it down in the description

below. But don't worry, I'll still give

you guys a quick recap of all the

important things as we break it down

here in this video as well. And because

you guys are awesome, I'm going to be

giving away the entire source code for

the project I built during the bake off

completely for free. Just click the link

down the description below so you can

get access to the front-end application,

plus all the different agents that I

built under the hood. But enough of

that. Let's go ahead and dive into

breaking down everything that went into

building out this agent project so you

can start to copy my tips and tricks for

building real world agents. All right.

So, what I want to do is paint the

picture of exactly what we were getting

ourselves into in this competition

because in a matter of five hours, we

had to go from a list of instructions,

requirements, all the way to a

full-blown working application that we

could show off to the judges. So, I just

want you guys to see how much we had to

do in 5 hours because you're going to

see, man, this is an insane amount of

work and the only way I was able to get

it done is by doing like AIdriven

development. So, that's exactly what I'm

going to be sharing with you guys in the

five tips section, but I just want to

paint a picture of what did we have to

build, what did we build, and then the

rest of the video, I'm going to show you

how we got there. So, let's break down

what we were tasked with doing because

this was a ton of fun, but stressful

because we had so much to build in such

short time. So, we had to create a

multi- aent system that builds the

future of personal finance. Now, what

does that actually mean? Well, we needed

to build out a beautiful UI where users

could go in and engage with agents. We

had to make sure that our agents we were

building offered proactive guidance to

help people accomplish their major life

goals for budgeting, doing vacations.

Outside of that, we needed to make sure

that our agents were intelligent. So,

not only did we need to include chat

bots where people could actively talk to

these agents, but we had to add in

workflows that automated a lot of the

works that people would normally go do

when like planning a trip and stuff like

that. Outside of that, just like you

would have to do in Top Chef where

you're like instructed to go make a

certain type of dish. Well, you have to

use certain ingredients as well. So,

inside of the bake off, we had to use

certain ingredients such as or in our

case certain technologies such as agent

development kit. We had to use the agent

agent protocol and we had to use Gemini

API. So this was a ton of fun. But what

I want to do is just break down like

let's actually get really concrete and

let me show you exactly what Google was

basically asking us to build. So at the

end of the day, here's what Google was

saying. They're saying, "Hey, we already

have an existing bank. It's boring. It's

an old bank, but this bank does come

with a backend and a front end, but most

importantly, this bank comes with an

agent. And as time goes on, agents

become more powerful and more prevalent.

Agentto agent protocol is going to

become huge where you are going to have

agents that are going to be talking to

other agents inside of companies to

where they do all the work and basically

make things magic for us. So what Google

was asking us to do inside this

competition is to build out everything

that you see right here in 5 hours.

Meaning we had to create a custom

application and we had to for each one

of the main topics that we were asked to

do like working with financial

statements, helping people plan their

goals, you know, a bunch of like

analyzing perks that might be available

to the customers inside the bank. Like

we had to build out agent workflows for

each one of these, which is insane for 5

hours. Not only that, but we had to

figure out how to connect our agents to

the bank's agent and we were able to do

that thanks to the A2A protocol. So, as

you can see, this was a ton of work, but

let me actually just show you a quick

overview of the application that was

built. So, you can see, you know, this

is what me and my partner built in 5

hours. So, super super powerful and

super super proud of what we built. So,

this is a full-blown application. So,

you can see we have multiple tabs to

help people achieve their different

goals. So, we have in each one of these

pages correlates to different agents and

agent workflows. So, you can see we have

spending. So inside this we have a

spending agent workflow where we had an

agent go off and analyze the person's

income, expenses, recent activities.

Outside of that we also had a you know a

other agent that was responsible for

asking and answering questions on

everything that you see on this page. So

as you can see like this was a ton of

work that had to get done in multiple

hours. So this is one part, this is

another part and this gets repeated on

every single page. And this was the way

I wanted to structure building out the

application. Definitely recommend you

checking out the full episode so you can

see how other people tackled it. But

once again, super excited for it to work

and just to show you guys, you can see

like what did I spend the most on this

month? This is triggering off an agent

that's asking questions over here about

what was spent on. So you can see the

most expensive thing that we did last

month was rent and you can see it right

here. So yeah, all around like it's a

working application. You can try it out.

You'll learn a ton of cool insights on

how we set up the agents to actually

handle working with Ato. So yeah,

there's a ton inside of here. I won't go

super super deep into actually how

everything was built. I definitely

recommend you guys hopping inside of

here and just asking AI like, "Hey,

please walk me through this." There's a

ton of cool really interesting places

that you can use to jump start your own

full stack AI development journey. But

what I want to mostly focus on is how

the heck were we able to build

everything that you see over here in

five hours from all the agents to the

full stack application to the agents

having tools to do a like this was a

monster task and I want to show you how

we did it in 5 hours and I'm going to

break it down right now in five tips

that you guys can copy. So the first tip

I want to share with you guys is the

concept of an AI reference project. Now,

this one tip alone is the single most

important tip that allowed me to go and

build out this full stack AI application

in a matter of 5 hours instead of 5 days

or more, truthfully. And the best way to

fully understand this tip, and don't

worry, I'm going to share examples of

how I actually did it. But the main

thing that you need to understand before

diving into what is an AI reference

project, you need to understand the new

job promotion you just got thanks to AI

agents. So you are now an AI developer.

You're no longer a software developer.

You're an AI software developer. What

that means is at this point you should

probably never be writing a single line

of code again. I have not written a

single line of code in probably close to

2 years at this point. What I have been

doing though and what I recommend you

guys to do and exactly what I did in

this competition is I provided context

to AI agents. What that means is I'm

telling AI here's what you should be

doing. Here's why you should be doing

it. And ideally, here is an example of

how you should do it. And that's what

really what I mean by AI reference. We

are referencing existing working code

and different projects so that we can

just go exponentially faster. So, let me

break down a little bit more what the

role means and then I'm going to break

down exactly how to apply and explain

what AI reference projects are. Okay.

So, here's what I mean. At this point,

our job is to provide context to AI

agents. We're not coding anymore. If

you're coding, you're going slow. So

what do we need to be doing as AI

software developers? Well, our job is to

know what exists. So what does a ad ADK

do? What does A2A do? What is possible

with these frameworks? What can I do

with ADK? What can't I do with ADK? When

it comes to A2A, what does it allow

agents to do? And also more importantly,

we need to know where can I find working

samples and examples of these different

frameworks. So, is there a example

project of ADK working properly? Is

there a working example of ADK using A2A

properly? Because if there is, there's

no reason for me to actually, you know,

type out and explain and manually type

out, all right, new function, go get

this, you know, card from this other

agent. No, what I should be doing is I

should be passing that information over

to AI and say, hey, AI, I know that this

tool can do it. Here's an example of

another project doing what I want. and I

would like you to tweak it for our use

case. That is what we should be doing in

the world of being AI developers. And

this is exactly what I did to crank out

five days work of work in 5 hours. So

let me give you a concrete example. In

our case, as you saw, we have to build

out an ADK application that has a full

stack application using ADK where ADK is

using A2A to talk to the bank agent. So

my whole job going into this competition

knowing my new role as a AI developer is

I'm like man I have to get smart on what

ADK can do. I have to get smart on

finding example projects. So when it is

game time I can say and just hey agents

go to work. Here's exactly what I want

you to build. So what does this actually

mean inside of your projects? Like what

should you be doing? Well what you

should be doing is you should be

preparing your projects to have a

reference folder. This reference folder

is combined with every type of project

reference that you can find. So you

should be looking up and adding in

existing applications. So in my case,

I've already built out A2A applications

in the past. I have found a ton of ADK

documents that explain exactly what you

can and can't do. I have projects of ADK

for building out tons of different

projects. So these are all different

projects that Google has created to

showcase the different powers of agents.

Outside of that, there is other agents

where there's projects that showcase how

to use ADK plus A2A. So my job at this

point, heck, there's even an A2A samples

repository that shows exactly how to use

ADK plus A2A. So my job is just to go

search the internet and I'm going to use

AI to do it. But I'm going to go search

all example projects and basically

prepare and stack the deck in my favor

when I'm going to start a new project.

So whenever it's time to hit go, I

already have a thousand repositories of

projects that explain exactly what

functionality we need to build. So in

our case when it comes to building out

this application all I'm basically

saying is like hey I would like you to

look at project one where they connected

their ADK agents to ATA. I would like

you to look at project two where they

connected ADK to the front end. And when

it comes to project three I would like

you to look at how they built out multi-

aent workflows where they had agent one

work with agent two to then spit out a

result. So, I'm hoping you guys can see

at this point the kicker here is we just

need to be basically understanding what

is possible and then just having like

you know in our heads just a bunch of

like little memories of like I remember

that did that I remember that did that.

So whenever it comes time to coding, we

can just pass all this into our

projects, specifically inside of our

reference folder, and then let our

agents do the work. Because the agents,

they're so smart. The second they see

the code from here and the code from

this other project, they'll go, "Oh

yeah, I can copy that for your new

project. That's going to be so easy.

Thank you for providing the necessary

context so I can implement exactly what

you want." So I'm hoping this is super

helpful cuz this is the exact process I

did to crank out weeks worth of work in

5 days. All right, so let's go ahead and

hop over to tip number two because if

you thought this one was super helpful,

you're going to love tip number two.

Also, if you're liking the idea of

reference projects, you're absolutely

going to love what we built for you

inside of Shipkit.AI, which is a

combination of pre-built ready projects,

AIdriven courses, and everything else

you need to launch AI applications in

days instead of months. And just inside

of Shipkit, like I said, you're going to

have access to a course where you get to

learn how to go from an idea. And AI is

going to help you every step along of

the way to go from idea to a full-blown

application to deploying your

application. Like I said, we have every

type of common AI project you would like

to use. Everything from agent

development kit to rag to chat,

everything. We have a full-blown

pre-existing AI application that's

working. You get the source code for it.

You also get example walkthroughs of how

I converted each one of these pre-built

templates over into a custom project.

And you get to see exact breakdowns of

how everything works. So, Shipkit is the

number one tool if you're looking to

build out real world AI projects using

these new technologies and tips and

tricks and see exactly how I build real

world applications in days instead of

months. And if you're looking to get

Shipkit, we're doing $50 off if you want

to use code bake off. And if you have

any questions, feel free, let me know.

But I definitely recommend checking

watching this video if you have any

questions or shoot me an email. But

yeah, thanks guys and let's get back to

tip number two. So the second tip I want

to show you guys is that you need to be

talking to your computer and this

absolutely broke everyone's brain at the

competition because everyone else is

sitting, you know, heads down, earphones

in, and they're just typing as fast as

they can. And I, on the other hand, am

just talking to my computer saying like,

hey, I think we should build this. Oh,

and this needs to connect to this. And

basically I'm just talking. And the way

I'm able to do that is using the tool

called Whisper Flow. And Whisper Flow

literally just listens to you. And they

have a bunch of cool tools in here to

help out if you're using tools like

Cursor or Claude Code where they'll also

look at your files and add them in. And

at this point, why I love Whisper Flow

so much is because I'm able to just go

as fast as I can talk. So if I can talk

faster, it'll listen. If I talk slower,

it'll listen. It doesn't matter. At this

point, I wish I could talk and type at

122 words per minute, but my fingers

just don't do it. And it's so much

easier just to sit back in your chair,

look up, and just describe what you want

and talk and then have the AI build it

for you. It's a funny thing at first,

but the second you start doing it,

you'll never go back to typing unless

you have to like, you know, call out

something specific. But just when you're

trying to solve the context problem,

which is what we're trying to do right

now, we're trying to put as much context

in our heads into the computer as

possible on how to solve the problem so

the agent can go off and do the work.

So, the more you can talk, the more you

can explain what you're looking for,

what problems you're running into, and

what the ideal goal state is, the better

these agents are going to do. And that's

why I love Whisper Flow because it

breaks down that barrier of preventing

me from putting more context into the

system. And if you want to get uh

Whisper Flow, not sponsored by them or

anything like that, which I was, but I

have a link in the description below

where you guys can get two months for

free of Whisper Flow. Absolutely love

it. But what I want to show you is just

Whisper Flow in action really fast. So,

I can update the shortcuts on my

computer to where whenever I now hit the

option and spacebar. I get this to where

I can just talk to my computer, it's

listening in real time. You can see down

here at the bottom of my screen, it has

the little squiggies. And this is where

I can just say like, "Hey, we're trying

to solve this problem. Make sure to look

up at setup.md file to see how we are

trying to tackle this problem." And

then, oh, by the way, this other

reference project solves the exact

thing. And then as soon as I'm done

talking and rambling, which is totally

fine to do, like you can ramble, it's

totally fine. the AI will just put that

in as context and boom, it'll work on

solving it and it's hooked up to cursor

so it knows whenever you call out a

file, oh, I need to include that file.

So, this thing is just insane. Now, if

you want to do poor man's version of

Whisper Flow, totally understand. I have

a cool thing I want to show you. If

you're on Mac, what you can do, you can

actually go over to settings and type in

the word dictation. I wish I could make

this bigger, but for some reason, they

don't let this get bigger. But what you

can also do is update the dictation

shortcut once you turn it on to hit the

right command key twice and you can

actually talk to the computer. So let me

show you what this one looks like cuz

this is also super helpful. So you can

say, "Hey, I'm just trying to show to

YouTube right now how cool it is to use

the dictation tool where you get to use

your Mac and just talk to it completely

for free." And this is automatically

included right out the gate when you're

using Mac OS. So yeah, as you can see,

this is a insanely cool tool. So, if

you're not able to type at 122 words per

minute, you definitely want to consider

using tools like Whisper Flow or

dictation so that you can get all the

ideas out of your head and into the

computer to help solve that context

problem so that these agents can work

their magic. So, yeah, that's tip number

two. So, let's go ahead and hop over to

tip number three. So, the third tip I

want to share with you guys is the

concept of building out an agent

workflow digital twin. Every time I have

shown someone in my free school

community or inside of Shipkit this

concept when they're building out

multi-agent workflows, the light bulb

goes off. They go, "Thank you, Brandon.

I will never build agents the same, and

I'm going to be using this every time

going forward." So, let me explain what

the digital twin concept is and how it

makes building agent workflows a

thousand times easier. So, I think

what's best is to let's cover the

problem first. So the problem is when

we're building out multi- aent

workflows, we're creating a bunch of

different files. So for example, to

build out this workflow right here to

where we have a root agent where our

root agent has sub agents and each sub

agent has, you know, different

callbacks, different tools, they might

access state differently. Well, as we

begin to build more and more complex

workflows, these grow in files. So we

are right now ending up with at least

four different files where if we ever

want to make a change to let's say our

root agent and our root agent changes

the way that it access state. So instead

of writing you know here's the goal

instead of writing the goal it now

writes here is the task. Well every one

of our sub aents that used to be looking

for goal well now it needs to be looking

for task. So, we accidentally just broke

all of our sub aents because as we're

making a change, the AI like cursor for

example is going to go, "Yeah, I I'll

happily update your root agent, but as a

result, we accidentally break everything

downstream." That's the issue. Now, here

is the solution. What we end up doing is

creating a digital twin that is a direct

replica of our actual workflow. So you

can see what we're basically doing is at

a high level we're just creating a

markdown file that says all right our

root agent our root agent has access to

these different sub aents in addition to

having access to those sub aents here's

the tools that it's going to do here's

the overall goal and what

responsibilities this agent does here's

the inputs of the agent here's the

outputs of the agent and we're basically

just replicating what's on the left and

we're putting it into a markdown file.

The reason why this is so helpful is

because anytime we go to actually make a

change like hey your goal now is to not

write the output to be like I said goal

it now should be task well whenever we

go to make the change now and we

actually pass in this markdown file

what's going to happen is our agent's

going to go hey I can see you're trying

to make this change but did you know

you're accidentally breaking the three

other agents that need this as a

required input and you're going to go oh

shoot thank you for telling me that I

will would like you to also go update

these other agents to make sure that

they reflect our change. Now, that's I

promise you the second you start

building digital twins of your agent

workflows, you're going to be like, "Oh

my gosh, this used to be such a pain in

the butt where I'd fix one thing and it

would break four other things." But now

it's working like a charm. So, and

here's exactly what you need to do. You

need to create, like I said, a agent

digital twin. And all this agent digital

twin needs to do is list out at a high

level what each agent does. And every

time you make a change, you're going to

update this file. So this file is going

to include, like I said, the name of the

agents, what they do, what tools,

callbacks, and everything else. And then

outside of that, you also just want to

list like the highlevel overview of what

each like how do all the agents connect.

And you want to just basically keep

replicating everything that's done over

here and actually just replicate it over

in your digital twin. You can definitely

create yourself. It's already included

in Shipkit. But this one change right

here, every person that has started to

create digital twins inside of their own

workflows, they never go back cuz the

second you just it works flawlessly and

you get to move a thousand times faster

and you can build more complex workflows

because everything's stable. And when

you make a change, you know where else

that change is going to cause impacts

downstream and you can fix it down

there, too. So, promise you guys,

digital twin is an absolute cheat code

if you're building out agent workflows.

All right, let's go ahead and hop over

to tip number four. So the fourth tip

that I want to share with you guys is

that you need to train AI to work with

your tech stack. This is one of the

biggest unfair advantages that you could

have to code a thousand times faster

than everyone else because while

everyone else is, you know, working on

implementing a feature and their agents

are adding mistake after mistake after

mistake and they're just going in a

circle saying, "Please AI, stop messing

up. Just build the feature. You're

already on the 10th feature and you're

already done with the project and on to

the next." And the way we're able to do

that is once again by training AI to

work on textX. So let me just give a

quick noob verse pro because I'm hoping

this is going to make sense when we

click it in. But how noobs usually use

these different tools like cursor and

cloud code is they open up a new chat

and they say hey AI please create me a

new ADK agent that's going to make a

tool call to get the weather. Now

they're going to hit enter. They're like

hell yeah I have AI working for me. And

then all of a sudden it's going to come

up with honestly I have no idea what

because ADK was not released in 2024

when the training cut off was for all

these models. So you're basically just

having AI in no man's land trying to do

something it doesn't know how to do. So

it's just going to produce something.

Good luck. I doubt it'll work. So what

we want to do is we want to train AI to

implement and actually know how to work

with our tech stack. And the way we do

that is we create something called a

task template. This is basically just an

expert who knows everything about the

tech stack that we're using. And this

expert is going to generate tasks. So

like if we were thinking about this in

the terms of people, we're basically

having an expert. This expert is going

to produce documents where these

documents provide the exact

step-by-steps instructions on what code

changes need to be made to actually get

the desired functionality that we want

inside of our codebase. So this is the

expert. The expert's going to produce

the task document and the task document

is what's going to be used to implement,

oh, we need to change this file and we

need to change this file. So that's what

we do. Now, how the heck do you make an

AI and train AI to be an expert at it?

Well, it's actually not that hard and

I'll show you an example um right now.

So this is what a task template looks

like. It is nothing more than a list of

instructions on how to use a specific

technology. And ideally what it's trying

to do is take in the desired

functionality that you're trying to

build. It understands the text stack in

and out and all the mistakes to avoid.

And then it's just going to write all of

the functionality to say, "Hey, when

we're trying to add the new feature that

they're asking for." Cool. Yeah, I'll

happily make that task and I'll do it

well cuz I know exactly what to avoid

and what mistakes to not make. And that

way whenever you go to make the code

change, this code change is actually

just going to be perfect. So here's what

it looks like and I'll show you how to

make one yourself in just a second. But

basically this document just contains

all of the common features and

functionalities that we'd want to do.

We've basically standardized writing

code. So what you want to do is you want

to say hey when you're working with ADK

you need to make sure that you can fully

analyze the current project from

beginning to end. So it needs to

understand the structure of an ADK

project which usually starts with a root

agent and a root agent has sub aents. In

addition to that, it has tools. In

addition to that, it has libraries. In

addition to that, like there's a, you

know, it basically just needs to know

the common structure of an ADK

application. From there, it needs to

understand what is what problems we're

actually trying to solve. From there, it

needs to understand some technical

requirements about like what actually

goes into building out ADK applications.

So, it needs to know like, hey, here's

what you should do when you're trying to

add a callback. Here's what are all the

types of callbacks there are. Here's

what you should never do when trying to

add callbacks. And you know, this is

just like a long long document that

describes all the best practices of

working with a specific technology. Now,

they're not that hard to make. And

that's what I want to show you right now

so that you can basically train your own

AI specialist so that when you're trying

to work on a task, you can easily knock

it out. So, here's what we have done.

We're trying to create an ADK task

template. And this is the genius on the

tech stack. And the whole purpose of

this genius is to create task documents.

These task documents once again they

just contain the instructions on how to

update the code. Now so you can see an

example of this. I just made one for you

guys. And let's look at this. So here's

an example of a task where a task just

describes, hey, you're trying to in our

case add the weather like we showed

earlier. So your goal is to do this.

Here's the goal. Now here is what you

need to do. You need to understand the

tool that you're working with, the

models, the different files that exist.

So the current state and basically just

keep going on from there on what changes

need to be made, the current state of

the application and you know it also is

going to include all the instructions

and it's automatically going to do a

good job because it knows not to do A

but it needs to do B. Now here's what

you can do to make your own task

basically your task genius because this

thing is the most important part to help

you go a thousand times faster. So what

you need to do is you need to say and

create a brand new markdown file and say

hey you are a specialist at ADK. Go use

context 7 to learn as much about this

technology as you can and your whole

goal is I'm going to give you an input

of what problem I'm trying to solve. And

your job is to create a task document

that includes all the code changes. And

then what you do is once you have V1 of

this task template set up, you take it

for a run. you take it for a spin and

you say, "Hey, please go add the weather

to this specific agent." And it's going

to come up with a task that looks just

like this to where it's going to go

update the weather. And then you're

going to apply that task and say, "Cool,

I'm going to go update the agent now."

And to start, it's going to fail. It's

going to write garbage code cuz it's

it's learning. And you're going to say,

"Hey, you made this mistake. Never make

this mistake again." Then you're going

to say, "Hey, make sure you add some

instructions in this task template to

avoid this mistake. Here's what you did

wrong. Here's what you should have

done." Then you do it again. And now

it's going to make a new task to add a

new tool to an agent. And you're going

to apply that task again to the code,

and it's going to do better, but it's

going to hit another error. And you're

going to go, "Hey, you actually forgot

to add context to the tool call. So

there was no way for us to save the

state of the weather to global state."

So once again, you made a mistake.

Please, ADK genius expert, never make

this mistake again. Please update your

instructions. And then you're going to

keep going through this over and over

and over again in a feedback loop until

you end up with what I'm calling the

task template that is responsible for

creating the task until this thing can

make task perfectly every time. So

you're going to go through this over and

over and over again. And you want to do

this for every technology stack. You can

do this for ADK, Nex.js, everything. And

eventually what's going to happen is

when you go to implement a new code

change, the task document is going to be

perfect and golden and exactly implement

the exact thing that you want. And it's

going to write perfect code whenever it

comes to actually implementing the

change. And that is what's going to

allow you to just move faster and build

out real functional code way quicker

than everyone else who's constantly

like, "Please AI, please work." And they

wonder why it doesn't work. And it's

because like it was never trained on

their tech stack in the first place. So,

of course, it doesn't have context on

how to solve the problem. So, hopefully

seeing this workflow in action is super

helpful because this is exactly what I

have done every time I go to work on a

new project. It does take some time

upfront to, you know, build out these

types of task templates, but the second

you put up the upfront work of maybe a

few hours, you're going to move faster

for the rest of time. So, I definitely

recommend checking out, you know,

building out your own ADK task

templates. If you have questions, always

feel free to drop into a free school

community. I'd be happy to go deeper

with this with you guys. So you can make

your own or we always have these in

shipkit so you can grab them there too.

But yeah, thanks guys and we're going to

go ahead and head over to test number

five which is where we really put some

gas on to cranking out code a thousand

times faster. And I'm excited to show

you this next one as well. All right, so

the fifth tip that I wanted to share

with you guys is that you should be

doing parallel AI development to move as

fast as possible in building out your AI

projects. Now what does this actually

mean? Well, it means inside of tools

like cursor, cloud code, windsurf, you

should be opening up multiple tabs at

the same time to work on different

features at the same time. And what this

means is, you know, we're going to kick

off this job right here. While that

guy's working, we're going to trigger

off this one. While that one's working,

then we're going to trigger off this

one. So, we basically have multiple

tasks running at the same time to start

building out our application. And by

implementing this, we are going to go so

fast it feels like cheating. Now, what

does this like? How do you do this in

practice? And why should we be doing

this? Let's go why first. Well, if you

were at a corporate company and let's

imagine you are the boss. Well, if you

had literally unlimited employees, it

would be silly to say, I'm only going to

allow employee number one to make code

changes. That's it. He's the only

employee that's allowed to make code

changes, and I'm going to wait for this

employee or intern to get back to me

before I do anything else. Like it would

be silly to build out an application

literally just one small feature after

another. Especially when most of the

time when building out applications

there's some stuff that you could make

changes to on the front end while at the

same time you could also probably make

some changes to the backend for another

feature or a new bug fix. Or if there's

multiple pages of your application,

there's nothing stopping you from

working on this page and this page at

the same time. Or if you're doing agent

development, there's nothing stopping

you from working on agent one. And while

that's taking 1 to 3 minutes to

implement, there's nothing stopping you

from working on agent two at the same

time to where you are like the main

concept I'm trying to get across here is

like you are the boss and there's the

best way to be working is to think about

it this way to where you are saying hey

intern one you know it is your job to go

work on this task. I know you're going

to need some time so go off and do it.

While you're working on that, I'm going

to call in another intern. And this

other intern is going to work on the

next feature. And I'm just going to

continually do this over and over again

for as many features as I can handle in

parallel. Like what's crazy is the

bottleneck in this workflow is us. It's

how many tasks we can, you know, keep up

with in our heads at the same time. So

like you'll see me in the bake off to

where I'm saying like you'll see this

throughout the episodes where I'm like,

"Hey, go make this change on the front

end." Oh, okay. Agent two, it's doing

this wrong. It should be doing this.

Okay, cool. For some reason, something's

going wrong when it comes to our login

page before we can go to the

application, work on this. And I'll

literally do this in parallel. I'll have

like five or six tabs working at the

same time. And then as soon as I'm done,

you know, looking at the task, cuz

that's the kicker. The intern does the

work and reports back to us the code

change and we quickly sign off on that

code change and then kick it off to the

next thing or we say, "Go make this

change." So we're constantly in in a new

paradigm as an AI developer. We're

providing context saying go work on this

and reviewing. Those are our two jobs.

Context and review. And you know to

review obviously you kind of need to

know a little bit about like the tech

stack and what's good code, what's

what's not good code. And you need to

understand like is this the actual

desired functionality and were any

mistakes made? But as long as you can

just quickly review these code changes,

you can work on many tasks in parallel.

and our brains in the amount of

different tasks we can handle, we become

the bottleneck. But what's crazy though

is we're working on four tasks at the

same time. So like truthfully me, I do

this all the time now. I feel like I'm

entering the matrix when I'm doing this,

but I'm getting a week's worth of work

done in a day by following this because

I'm doing five things at the same time.

So this is it's just a mind-blowing tip

and I cannot recommend you guys enough

to do this. And so basically when you

kind of start stacking everything that

we've talked about today on top of each

other, you guys are going to be

unstoppable. So, you know, when you guys

are using Whisper Flow to actually talk

to your computer, you're going to be

typing faster. So, you know, in this

case, you're going to be typing at, you

know, 122 words per minute. Also, you're

going to be using in your own case,

you're going to be using task templates,

which are specialist at implementing

code. So these task templates are going

to make sure that you write quality code

to implement the desired feature. So

you're going to be inputting stuff

faster to the computer. When the agents

are working, they're going to be doing

better work. In addition to that, you

guys are also going to be working in

parallel at the same time on multiple

different tasks. So you're like

multiplying your efforts as well. And

these just all stack on top of each

other one at a time. And when you are

working on task, you also have a ton of

AI reference projects that basically

call out exactly the desired

functionality that you wanted in the

first place. So between the task

templates and the reference projects, my

god, you guys are going to be moving so

fast. So this is one of the ways to

where I was able to in the bake off was

one of the only people that was able to

actually build and complete everything

in the 5-hour allocation and have a

working project to show at the end of

it. And the only way I was able to get

it done is to follow these exact

strategies that I've been sharing with

you guys today. So, I'm hoping you've

had the light bulb moment and you're

like, man, I want to implement these so

bad. And I think the best way to get

started, like I said, I have the free

school community. I would hop over. We

have weekly free coaching calls every

Tuesday at 600 p.m. Eastern time. Would

love to help you guys. If you have any

questions on any of this, walk you

through exactly how you can use some of

this inside of your own applications and

your own workflows. Super happy to help.

and we have a ton of awesome other AI

developers on the call. So, I think

you'll really like to get to meet a lot

of developers who are on the same

journey because we're all learning and

getting better at the same time. But

yeah, that is the five tips that I think

you guys should definitely be

implementing to help you build a

thousand times faster when trying to

crank out real world AI projects. So, I

hoped you guys enjoyed seeing all the

behindthe-scenes tools, tips, and tricks

on how I was able to crank out the

projects for the ADK agent bake off and

was able to win the whole thing. I had

an absolute amazing time. Shout out to

Google for hosting such an amazing

event. And quick reminders, you can

download all the source code for the

completed project that I did at the bake

off completely for free. Just click the

link down description below. You can

also I have a ton of 80K related content

right here on this channel. everything

from an ADK master class, do some deep

dives into voice agents, rag agents, so

many other tips and tricks on ADK. So, I

definitely recommend checking out those

on the channel. And I also recommend you

checking out the school community I have

for you guys where you get to hop on

weekly coaching calls with me and a

bunch of other AI developers on

everyone's on their own journey. We all

work together to help make sure

everyone's making progress. And if you

want to jumpstart your AI development

journey, I cannot recommend enough for

you guys to check out Shipkit where

you're going to get access to all sorts

of pre-built AI projects so that you can

implement a lot of the different

features we talked about and tips in

today's video. And if you have any

questions on it, feel free to always

shoot me an email at brandon@shipkit.ai.

But enough of that. Let's go ahead and I

recommend you checking out whichever

video is popping up on the screen right

now. And I cannot wait to see you guys

in the next one. See you.