►
A
Yeah,
okay,
here
we
go
yeah
are
we
here
are
we
live
all
right,
live
from
wonderland,
okay,
so
sweet?
Okay.
So
where
are
we
at?
Well?
Let
me
just
say:
okay,
so
sid's
here
sid
might
be
asking
some
questions
along
the
way,
and
you
want
to
say
I
said
you
just
say
hello,
all
right.
That's
it
sweet!
Okay!
A
Today
we're
going
to
be
looking
at
the
community
standards,
and
so
we're
going
to
be
moving
on
from
the
the
stuff
that
we're
we're
already
moving
into
the
next
the
next
month.
But
you
know
we're
not
really
writing
these
in
order.
So
all
right,
so
we
just
generated
threats,
md
right
and
the
last
chapter
one
is
about
generating
threats,
md
and
and
john
whiteman,
and
I
presented
on
that
at
absent,
pacific
northwest.
A
Was
it
last
weekend
on
saturday?
So
then
that
recording
is
not
yet
live
on
their
youtube,
but
we'll
post
that
when
it
is
so
then,
and
there
in
that
demo
right,
we
saw
some
of
the
work
from
chapter
one
where
we
that
that
tutorial
series
in
chapter
one
that
word
where
we're
doing
to
build.
You
know
the
the
threats
md
files
so
as
to
go
down
the
dependency,
rabbit,
hole
again
right
and
figure
out.
A
What
is
that
tree
of
dependencies
that
are
going
to
be
within
our
threat
model
right,
so
we're
so
we're
just
jumping
ahead
a
little
bit
here
due
to
some
other
stuff
that
I
have
to
do
so.
You
know
we're
we're
taking
what
we
can
we're,
what
we
can
get
where
we
can
get
it
so
right
now
we're
gonna
jump
into
what
we
would
have
otherwise
done
started
next
month,
but
we'll
just
do
them
both
in
parallel.
A
A
You
have
some
assurance
on
the
level
of
quality
of
what
you're
getting
right.
So,
let's
dive
into
this.
So
what
so?
What
do
we
need
to
do
this
right?
So
we
need
these
files
and
github
has
already
provided
us
with
some
standard
content
for
these
files.
So
what
we
can
do
is
we
can
just
have
alice
proactively,
go
out
and
we
can
say:
hey.
You
know,
alice
help.
A
A
A
A
A
What
we're
going
to
do
is
we're
going
to
move
into
writing
the
code
which
will
be
you
know
the
the
product
of
the
tutorial,
which
is
the
docs
page,
that
we've
been
we've
been
editing
right
and
in
that
we
will
basically
take
this
snippet,
which
we
start
with
up
here
right
and
it
won't.
It
won't
work
at
the
beginning
of
the
tutorial
and
then
at
the
end
of
the
tutorial,
it
will
work
right,
and
so
what
is
work
well
work
in
this
case?
A
If
we
don't
know
how
right
now
we're
just
going
to
sort
of
get
it
get
a
set,
maybe
five
of
them
something
right,
and
so
so,
once
again,
you
know
we're
gonna.
Take
this
proactive
approach,
she'll
open
the
issues
at
our
request,
and
then
she
will
attempt
to
open
pull
requests
for
the
ones
that
that
she
sees
potential
options
for
and
in
the
future,
some
some
options
which
we
could
expand.
This
flow
we
could
potentially
start.
A
The
focus
of
today
is
is
making
sure
that
we
can
get
those
issues
and
prs
associated
so
that
alice
can
take
a
proactive
approach
to
the
open
source
guides
and
the
fulfilling
of
the
community
standards
for
a
project
right
so
that
she
can
actually
start
helping.
So
then,
after
we
know
that
she
can
help
and
she's
been
successfully
helping
a
project
right,
then
we're
going
to
start
to
split
out
the
the
the
the
the
creation
of
the
issues
and
the
pr's
from
the
rest
of
the
flow.
A
And
so,
if
we
want
you
know,
if
we
want
to
build
this
ghost
in
the
shell,
then
we're
going
to
think
about.
How
do
we
build
a
shell
and
and
how
do
we
capture?
You
know
all
this?
This
chain
of
system
context
this
this
train
of
thought,
so
we'll
jump
back
into
that
momentarily,
build
that
with
our
cli
command,
so
not
as
fleshed
out
losing
some
of
those
implementations
that
are
stored
in
memory
just
for
now.
A
A
Well,
we'll
have
a
data
flow
which
is
alice,
which
will
go
through
the
recording
transcripts
and
the
video
recording
and
link
it
up
with
this
notebook
file
so
that
we
can
automatically
generate
that
the
documentation
off
of
our
work,
as
is
recorded
or
streamed.
It
doesn't
have
to
be
to
youtube,
but
we
can
we
can
plug
the
text-to-speech
with
anything
else.
So,
let's
see
okay,
so
that's
the
the
near-field
next
steps
all
right.
A
All
right,
so,
okay,
we
have
the
templates,
so
here
yeah,
so
first,
you
know
what
do
we
do?
Well,
what's
what's
the
generic
process
right?
So
we
we
always
start
with
document
everything
we
know
right
so
so
what
is
everything
we
know?
This
is
basically
our
our
link
dump.
Maybe
our
you
know
from
our
tabs
that
we
did
the
other
day,
let's
just
just
grab
all
the
relevant
stuff
that
we
might
use
as
references.
A
A
Okay,
so,
and
then
let's
just
write
a
little
note,
what
are
we
doing?
We're
going
to
alice
will
be
taking,
and
I'm
going
to
write
this
in
a
comment,
because
this
is
not
really
something
that
oh.
Why
would
I
don't
this?
This
is
more
of
a
comment
on
what
will
be
the
content
there
now,
rather
than
the
content,
and
it's
important
to
distinguish
the
difference
between
the
the
voice
of
the
the
note
and
the
text.