kpt-labs-vault/05-Dashboard/YouTube/NVkRkioBXQc - One markdown file just fixed AI coding forever_.md

---
video_id: NVkRkioBXQc | title: "One markdown file just fixed AI coding forever." | date: 2026-06-22T08:04:33.851107
sentiment: neutral | category: Other
duration: 1148 | views: 48099 | channel: Agent Zero
tags: [youtube, video, automatisch-verarbeitet]
**Quelle:** yt_dlp_subs+translate | **Sprache:** en
---

# One markdown file just fixed AI coding forever.

**Kanal:** Agent Zero | **Dauer:** 1148s | **Aufrufe:** 48099

## Zusammenfassung


## Key Points


## Takeaways


## Transkript
Welcome.
Today
I'm
about
to
show
you
how
you
can
leverage
single
small
marground
file
to
fix
your
AI
coding
agent's
biggest
issue
ever.
My
name
is
Yan.
I'm
the
developer
of
Agent
Zero
and
Space
Agent.
And
today
will
show
you
how
to
properly
use
Docs.
It
is
extremely
simple.
No
installation,
no
requirements.
And
the
best
part
is
that
it
actually
fixes
the
issue.
So
now
what
is
the
issue?
obviously
is
the
reliability
of
coding
AI
agents
and
we
all
know
the
symptoms.
You
give
your
AI
agent
the
task.
It
will
do
the
task
but
in
wrong
place
breaking
your
conventions
duplicating
functionality
instead
of
extending
function
that
could
have
just
one
line
addit.
It
will
create
brand
new
helper
module
etc.
Your
codebase
will
bloat
and
this
makes
things
even
worse
for
the
future.
And
you
know
how
this
ends
right?
never-
ending
cycles
of
debugging,
fixing
one
thing
breaks
another,
your
agent
is
confused
from
all
the
code,
etc.
So
now
will
show
you
what
docs
actually
is,
why
is
it
so
simple
and
why
it
works
so
well,
why
did
we
develop
it
and
how
can
you
use
it
in
your
project.
So
first
we
need
to
identify
what
is
the
real
problem
here.
The
issue
is
not
intelligence,
it's
context
awareness.
Because
your
agent
is
already
smart
enough,
your
LLM
is
smart
enough
to
do
any
programming
work
better
than
you
can.
But
where
it
fails
is
maintaining
large
code
bases
because
it
doesn't
see
behind
the
corner.
It
does
not
know
the
context
of
your
full
codebase.
And
that's
why
it
makes
these
simple
mistakes
because
it
simply
cannot
see
the
big
picture.
and
throwing
more
tokens
at
it.
That's
not
solution.
The
question
is
not
how
do
we
give
it
more
context.
The
question
is
how
do
we
give
it
exactly
the
right
amount
of
context
it
needs.
Not
more,
not
less,
minimum
context
required
to
make
the
minimal
edit
and
that's
it.
Now
to
understand
why
did
develop
docs,
we
need
to
take
look
at
space
agent
because
this
is
where
it
started.
Space
Agent,
if
you
don't
know
what
it
is,
it's
an
AI
agent
that
runs
completely
in
the
browser
runtime.
It
can
execute
code.
It
can
generate
its
own
UIs
on
the
fly.
It
can
communicate
to
external
services.
You
tell
it
to
build
you
something,
it
will
build
it
on
the
fly
right
away
in
the
browser.
And
it
has
ton
of
advanced
features
like
uh
user
management,
uh
groups.
It
is
extensible
in
many
many
ways.
It
has
large
code
base,
lot
of
layers,
lot
of
concepts,
lot
of
cool
features
like
the
time
travel
and
it
was
completely
developed
by
AI.
didn't
write
single
line
of
code
on
this
project.
And
it
took
me
about
weeks
to
completely
develop
Polish
and
publish
this.
And
so
since
the
very
beginning,
knew
that
cannot
be
writing
code
here.
It's
not
possible
in
2026.
You
need
to
have
team
of
agents
that
will
do
this
for
you,
but
you
need
them
to
do
it
reliably
and
to
write
good
quality
code,
maintain
uh
maintain
the
right
principles
and
uh
best
practices
etc.
And
so
the
very
thing
did
inside
space
agent
was
creating
this
agents.md
file
where
back
then
it
wasn't
called
docs
framework.
It
was
just
the
first
prototype
of
self-documenting
framework
built
specifically
for
the
space
agent
project.
But
it
was
mostly
what
docs
framework
is
now.
It
explained
to
this
agent
to
read
documentation
before
editing,
update
documentation
after
editing,
maintain
the
documentation
in
hierarchy
corresponding
to
the
codebase
and
how
the
documentation
should
look
like.
So
like
we
say
here,
docs
is
self-documenting
agents.mmd
framework.
The
big
difference
here
is
that
it's
not
single
agents.mmd
file.
It's
not
documentation
that's
detached
from
the
codebase
somewhere.
What
we
are
used
to
lot
of
projects
have
their
documentations
in
wiki
somewhere
or
in
separate
folder.
Here
we
tightly
couple
the
documentation
with
the
codebase.
And
can
show
it
to
you
here.
This
is
the
code
base
of
agent
zero
for
example.
It's
very
large
project,
very
large
code
base,
very
deep
and
it
all
starts
with
the
top
level
agents.mmd
file.
Here
we
have
our
original
agent
zero
instructions
and
somewhere
here
starts
the
docs
framework
which
is
one
of
the
beauties
of
it.
You
can
simply
take
the
markdown
from
the
GitHub
repo,
copy
paste
it
into
your
existing
agents.mmd.
It
does
not
mess
up
your
existing
instructions.
It
just
adds
the
let's
say
responsibility
to
your
agent
for
the
documentation.
Now
the
agent
knows
that
it
needs
to
crawl
the
hierarchy
of
agents.mmd
files
because
each
agents.mmd
is
created
in
every
subfolder
throughout
the
codebase
except
for
some
temporary
files
and
garbage
etc.
And
every
agents.mmd
file
is
responsible
for
single
domain,
single
folder,
but
it
contains
child
docs
index.
And
we
are
now
in
the
top
level
agents.mmd.
And
here
we
have
our
subfolders
agents
API
configuration,
docker,
etc.
Each
of
these
have
their
own
agents.md
files
inside
that
document
that
one
specific
domain.
And
for
example
in
the
agents
we
will
once
again
find
child
doc
index
at
the
end
documenting
individual
agents
inside
of
the
system.
And
why
this
tree
structure
is
so
important
is
t

[YouTube →](https://youtube.com/watch?v=NVkRkioBXQc)
---
_Verarbeitet: 2026-06-22 08:04_