Okay, today we're going to go over

something very, very simple and it has

to do with how you're talking to AI or

the information that you're giving AI.

Really, the words you're using will be

the important aspect. I'm going to keep

this pretty short, pretty simple, and

give you an example of basically showing

you that it really, really matters. This

will feel really remedial to a lot of

people, but hang on, you might actually

see something that you haven't quite

seen in action. It's just something that

you've intuited for now.

Okay, so what we're going to do is going

to go through a a simple example that I

show the classes that I teach all over

the place and it is kind of an

eye-opener for some people. So, let's

hang on. The real premise here is the

way you communicate with a model truly

matters. Now, a lot of us will say,

"Yeah, of course. Depending upon what

you say is what it does." But, I mean in

a really specific way. And also, I will

cover a little bit about those agent

files, the agents.md or claude.md

depending upon which agent you use to

better understand what's going on there,

when they're valuable, and really when

they're read. I know all of this sounds

kind of weird right now. Hang on, it's

going to be pretty quick. Let's dive

into Visual Studio Code so that I can

show you what I'm talking about. Okay,

very simply, what I'm going to do I've

created a folder called hello. I'm going

to open this folder

with Visual Studio Code. So, what I've

opened this project, the folder that we

saw, the hello folder, inside of Visual

Studio Code. The only reason is so that

we can see the files. I also came over

here and did new file. We have one

called data.txt. Inside of there, I said

the best color is purple. The reason I'm

doing this is imagine there's a bunch of

files over here with mixed information.

These are my notes. This is the stuff

that I'm trying to contextualize and we

come down here and we open Codex and we

simply ask Codex, "What is the best

color?" It tells me the best color for

most things is apparently deep teal. I

didn't know that. I thought it was

purple. Okay. So, what you're seeing

here is the fact that the system doesn't

know that you have files that have this

information in it, and they're not going

to go and read every single file inside

of your project. That's an important

detail for you to understand.

Secondarily, dependent upon how you talk

to this agent, it's very, very

important. So, let's create a new

context here, clean up, so that we have

a plain context and say, "Find the best

color." Okay. So, now we're talking

about verbs. I used the word find. Now,

find is obviously a very discrete verb

that's telling it something. It's kind

of an action that it can take. So, what

we expect is it will start looking

around inside of the system, and it will

find the data.txt file, it will look

inside of the data.txt file and tell us

purple. That one detail, what is the

best color versus find the best color,

how you use that word, what verbs you

use, those are incredibly important.

It's hard to describe how important

which word you use in your long

conversations and in your long intent

when you communicate to an

to a to an agent what it's going to do.

So, I know that sounds remedial, but if

English is your second language, or if

you find that you can't often describe

yourself all that well, then it's going

to be a little bit more difficult to get

the best out of this. So, number one tip

that I have for you, this is really the

best tip I've got, is pay attention

to the way you're describing things and

asking for things, and try to get a

little better. This is a learnable

skill. This absolutely can make a

difference. It will absolutely make a

difference using AI, but it'll make a

difference everywhere. So, your

communicative capability will, of

course, increase if you're paying

attention to what would be the verb I

would use here. What's a better Of

course, talk to your agent if you're

trying to get better at that. If you're

not getting the results back that you

want, and you think you asked for it

correctly, tell the agent, "I was

expecting you to do this and this and

this. How could I have asked for that?

And the agent will tell you, but pay

attention somewhat to the language. I

have a second tip here. It's kind of be

more verbose. If you're trying to say,

let's imagine we did it a different way.

And I'm going to use um kind of

speech-to-text here. So, I'm going to

turn on the speech-to-text. Hey, I have

files here that describe the best color.

What is the best color? So, now I'm just

giving it more context, more kind of

intent. I'm telling it what I believe is

inside of the project that has it has

access to. And it's very likely then to

say, "Oh, I see. You think inside of the

files I might find that information."

So, you might say, "In all of my

meetings, I think I asked a couple

questions of Jane. Can you find those?"

It's much more likely to give you that

answer back rather than just saying,

"What did I ask Jane?" So, those two

ways of asking that exact same question,

you're orienting the system. So, my

advice is talk. I cover this quite a bit

on my channel. Talk to your agent. Don't

type to your agent. Because if you type,

you're going to edit things and you're

going to make it very succinct and think

that's better, but you have to choose

the right words when you're typing. If

you're talking, it's much more likely

that you'll hit the kind of target area

that you're thinking the agent should

take as well. You don't need to tell it

what to do. You shouldn't say, "Read the

data.txt file and tell me what Well,

that will work perfectly if you know the

only place the best color is listed is

inside of data.txt. Fantastic. Then it

won't do a a broad search. It'll do a

narrow search. So, even that is a very

good clue. But if you're not really sure

and you're kind of thinking, you know,

somewhere in my data here, I described

the best color. Can you tell me what it

is? That will work as well. So, how you

communicate here is really, really

important. Okay, with that, I want to

add one more thing to this. I know this

is a pretty simple one. I want to talk

about one other version of how you talk

to your agent. It is kind of using these

agent files. If you haven't heard of an

agent file, we've called them many

things in the past, the memory file, the

Claude file, the Gemini file. All these

are kind of these main files that are

read when you start a conversation. So,

let me describe that to you. When you

start a new conversation in one of these

agents, the first thing those agents

look for is their memory file or their

agents file. Now, in something like

Codex or Cursor or Open Code or those

kinds of things, they're looking for a

file called agents.md in the root folder

project that you're that you're dealing

with. If you happen to be using Claude

Code, it's still the one that uses

Claude.md.

And if you're using something like

antigravity, then they're using, I

believe, agents.md by default these

days, but you can still use a Gemini.md

as well. Very complicated, I know. The

concept really is there's one file that

is kind of the first thing that's that's

brought in to a conversation. And the

way to describe this is let's drop that

back down into Visual Studio Code, and

I'll show you what it looks like. But I

want to tell you up front what's really

happening that you can't see, and you

can't see it intentionally. They're

hiding it only because it would be

confusing if they showed it to you.

When you do that {slash} new or start a

new conversation or open the agent the

first time, the first thing it does is

it takes the contents of that agents

file and sends it into the conversation

as if you would just typed it yourself.

So, the first thing it does is it

precedes the application or the

conversation with that information. It's

the best way to perceive of it is if I

wanted to

my system to know something, I would

type it out. Whatever I put in that

file, I'm always typing out at the

beginning of a conversation, so all

conversations have it. That's really the

cornerstone of what this file does. All

right, let's dive in and take a look at

this. We are in Visual Studio Code once

again, so easy. I do not yet have an

agents file. We're going to start an

agent here. We're going to go straight

into Codex and we're going to say, "What

is the best number?" So, at the

beginning of this conversation, we would

throw whatever's in that agent's file at

the top, but we don't have an agent's

file yet. So, let's add an agent's file

here and put in the best number is 1 2 3

and now ask that question one more time

and it picks some random number that it

Well, maybe not random, then maybe this

is its favorite number, 37. So, I wanted

to show you this. We added the agent's

file after the conversation had started

to just kind of show you that the

agent's file is thrown at the top of a

conversation that's new. If the If the

conversation's already happening and you

put something in the agent's file or you

create it, it won't sneak into the

conversation. So, let's create a new

conversation here. So, that's just like

we restarted Codex and ask the same

question and immediately responds with 1

2 3 because actually, you can imagine

what we just typed to the agent.

Everything that was sent to the LLM was,

"The best number is 1 2 3. What is the

best number?" And of course, the LLM

didn't have to do anything but 1 2 3.

So, it sent that right back. So, that's

what's really going on. Anything inside

of this agent's file is is kind of

prefixing everything inside of the

conversation. A new conversation gets

the agent's file. I just want to lock

that in because it's really meaningful.

The reason this file is so valuable is

if you keep doing certain things in a

project. The reason that I teach the

folder project as it is is each project

or each folder is kind of its own idea.

I was having a meeting yesterday about

XYZ. That might be its own folder or a

project that we've been working on and

we're going to have 10 meetings about.

I'm going to put all the meeting notes

here. That might be a folder. Or I'm

taking a trip this weekend to a new

location. I'm going to try out a new

hotel. I kind of want to know what's

near it. Those kinds of things. That

might be a folder. Each one of those has

its own real unique kind of localized

context, but you might not want to ask

the same things again and again. The

agents file is there as kind of uh

preceding

what you might type in so that the

system always understands what you want.

So, if I went to our agents file and

said, "Always precede all responses that

you give me with a robot emoji." And we

hit save. Now, of course, if we say

hello here, we don't expect that robot

emoji as we've just learned, but if we

say hello in a new context, then what we

anticipate is we will get the robot

emoji back. So, as you can imagine, you

start putting things in here. All of my

files that deal with my taxes are in

this folder. All of the information that

you might need to know about for Y might

be found over there. What I like to do

most in this environment is X. I always

commit after every change that we make

to I always run tests. All of those

kinds of things is what really work well

in this agents file. I don't advise you

clutter it with literally everything cuz

what you need to think about is, "What

do I really need the system to be able

to do or the workflow that I expect it

to do all of the time? Or you can put

something in like, "Every time I ask you

to commit, here's the steps I want you

to take." Now, that actually would be

probably better in a

local skill for this this folder or

maybe a command or something like that,

but it works perfectly fine in your

agents file. So, your agents file is the

first place for you to start exploring

how to systematize conversations or the

workflow inside of a project or even

tools. Here is a tool that I wrote. It's

this this this.sh. Use it if you ever

need to look up X, Y, and Z. That would

orient every conversation. If you ever

need to use something that that needs

that information, it will use that tool.

So, just it's a really useful useful uh

pattern to get used to, but

understanding why it's there and when

you can edit it. By the way, uh you can

say, "Remember that I really love

running and I hate sleeping. Put that in

my agent's file." And of course, what we

expect to see is it will go in, it will

find the agent's file itself, and it

says, "You really love running and hate

sleeping." And now, here's something

that I'll show you. Let's say, "I want

to do an activity right now. What should

I do?" Now, because we told the agent to

send that information, we also have that

information in our context. So, if

you're updating it locally and you're

telling the agent to update it, then

it'll already be in your context. You

don't have to start a new conversation

every time to get that information.

Seems obvious, just want to call that

out. But this agent's file is really a

really cool unlock. Okay, I just wanted

to show a few of the very, very simple

principles. How you communicate to your

agent truly matters, and it's one of the

reasons I highly advise talking instead

of typing, because you will put down a

context the agent has more purchase on,

has more chance to understand what

you're trying to ask for or do, or what

your intention is. That's the intent.

I'll shoot a whole video on intent. Hang

around if you want to see that. Um but

also the agent's file, or your kind of

agent's or Claude or Gemini or whatever

file that you might need, precedes all

of your conversation as if you had typed

it in. So, there's not any real magic

going on, it's just part of that

conversational text, but you just don't

see it at the top of your conversation.

In fact, I don't know what it was I

think Codex for a while was showing

exactly what's in that file at the top,

but I think it was confusing to a bunch

of people cuz usually it would be a

whole bunch of information about how to

run the project, how to build the

project, all this stuff that people

didn't think they

they needed to send to the model, they

were sending. It also will use up some

of your context, so keep it small and

only put the things in there that are

really useful. Figure out other ways,

like create another file called running

my system, and then you can say, "Hey,

use running my system to do whatever I

might need to do." That is something I

call promptware. Again, a different

video that I'm going to shoot. Hope this

helped. Thanks for coming along for the

ride on this one and I'll see you in the

next one.