Stop Using Claude Code Without an Agentic OS

---
title: "Stop Using Claude Code Without an Agentic OS"
video_id: Bgxsx8slDEA
source: https://www.youtube.com/watch?v=Bgxsx8slDEA
date: 2026-05-06
type: transcript
---

# Stop Using Claude Code Without an Agentic OS

[Źródło](https://www.youtube.com/watch?v=Bgxsx8slDEA)

## Transkrypcja

Most people use cloud code like a slot
machine. They're just using random
prompts on random tasks and ultimately
getting random results. But if we
instead use an agentic OS, we can create
a system that we can optimize, track,
and ultimately hand off to members of
our team or clients. with a clawed code
agentic OS. We turn your daily workflows
into skills, skills into automations,
and automations into architecture before
we wrap the entire thing in a memory and
observability layer. And today I'm going
to show you how to do all of this in
three steps and in the process put you
ahead of 99% of cloud code users. When
we talk about Nentic OS, there's three
things we're going to cover in relates
to the three steps for building it.
First is the observability layer and
that's what you see here. This is sort
of a dashboard visual setup that lets us
interact with our OS from outside the
terminal. Number two is the memory layer
and this is where the Carpathy Obsidian
Rag setup comes into play. And lastly,
and I would say most importantly is the
architecture, the skill setup. When I
talked about in the intro of taking your
daily workflows, turning them into
skills, skills into automations, and
automations and architecture, I'm
talking about this. This is the backbone
and this is what actually is the value
ad of an Aentic OS. It's not the fancy
dashboard as cool as this thing is,
right? This isn't the true value. This
is the true value. So, what is this
architecture? Why should you care? And
how do we set it up? Well, this right
here is essentially a visual of
everything Cloud Code should be doing
for you, codifying it, and ultimately
automating it. The idea is simple. We
have you in Claude Code. And if you're
like most people, this is kind of where
it ends. You have the terminal open. You
ask it to do random task. There is no
system. There are no steps. Nothing is
tracked. Nothing is optimized. In our
Aentic OS system, what we have done
instead is we have broken down
everything you do on a personal level
and more importantly at a business
level. And we've broken them up into
domains. So for me, I have memory,
productivity, research, content,
community, on and on and on. what you
would have specifically would be
different depending on what you do. But
the idea is we do a lot of different
things and they have specific domains.
For example, let's take a look at the
research domain. I do a lot of research
and under each domain are a number of
discrete or individual tasks. For me,
I'm often looking stuff up on YouTube. I
need to do deep research into things. I
need to deal with light rag. I want to
have a morning report. I want to watch
my competitors. On and on and on and on.
So, every domain is going to have
individual tasks. Each of these tasks,
if this is something we do regularly, a,
it should be in here, but B, we can turn
it into a skill. And this can be things
that are relatively simple, like this
YouTube search. Hey, instead of me just
going into YouTube and typing something
in there, why don't I turn that into a
skill and get a complete report every
time? This can also get more
complicated. Something like deep
research isn't just me telling Claude
Code, do deep research. This is me
looking at Twitter, GitHub, the web,
YouTube still, but even more so, taking
a look at previous entries in Obsidian
to see what I've talked about in the
past and consolidating all of it. The
point is, you do a lot of different
things across a lot of different domains
in your day-to-day life and in your
business life. Have you codified it in
this manner? Have you turned every task
into a skill? Do you have a way of
tracking all this and optimizing it?
Chances are no. And if that's the case,
even if you do nothing else with this
whole cloud OS system, doing the memory,
doing the dashboard, all that cool
stuff, if you just stopped here, you
would get a ton of value. So, we've
broken up our life and our business into
different domains. We've broken up the
domains into tasks. Those tasks become
skills. Now, the next step is to take
those skills and turn them into
automations. Now, not everything needs
to be automated, but some things do.
Take a look at the morning trend
scanned. This is obviously something I
would want every single morning that
populates inside my Obsidian database
saying here's the scan of what's going
on in AI and your competitors on YouTube
on GitHub etc etc right that's an easy
win in terms of an automation now
automations can really come in two
flavors when we talk about automations
they can either be local automations or
they can be remote automations luckily
for us we don't even need to know which
ones they should be because you know
who's good at figuring out claude code
and if I tell cla code I want to create
a local automation or remote automation
and it will be able to figure it out.
But what you care about isn't me going
into the minutia of local versus remote
automations. What you care about is
Chase, how can I create this? How can I
figure this out? Well, luckily for you,
it's not too difficult. All you need is
this prompt. But before we go into that,
quick word from today's sponsor, me. So,
I just released my Cloud Code Masterass,
and it is the number one way to go from
zero to AI dev, especially if you don't
come from a technical background.
Everything you see in today's video,
from the prompts to my actual Agentic OS
system that I use myself, can be found
inside of here. So, if you want to get
your hands on that, there's a link to it
in the pin comment. Hope to see you
there. So, like I just said, this exact
prompt that we are going to use can be
found inside of my community. And the
idea is this is going to kick off a
conversation between you and Claude
Code. So, you can build something like
this. In general, the way it's going to
start is you and Claude Code are just
going to have an open conversation. I
suggest opening up the terminal, turning
on your microphone, and just doing a
stream of consciousness, sort of
explaining what you do dayto-day and
what your discrete your specific tasks
are. From there, it's going to continue
to have a back and forth with you, and
then it's going to be like, okay, you're
doing X, Y, and Z. Can we turn X, Y, and
Z into a skill? If we can turn it into a
skill, does it make sense to then turn
it into an automation? Like I said, not
everything needs to be an automation.
Something like the morning trend scan
makes total sense. Deep research, not so
much. But it's going to go through each
and every task, create a skill for you,
so you can execute that task the same
way every single time. And it's going to
use the skill creator skill. And then
it's going to figure out does it need to
be an automation? And if it's an
automation, does it need to be local or
does it need to be remote? It's going to
continue that process for each and every
domain you spell out. So, it's not going
to be just what you see here. If you
don't do research, you don't do content,
you don't run an AI agency, that's fine.
But whatever it is you do, we're going
to create a domain for it. Create
skills, create automations, and in the
process, you create this backbone of a
cloud code powered agentic OS. You are
codifying behaviors in a way that we can
track and we can optimize. That way when
you show up to Claude Code and you use
the system, you're not just guessing
every single time and hoping that Claude
Code does the same thing it did
yesterday. And the power of that goes
beyond just you as the individual using
this Cloud Code system. If you're
someone who works on a team or you're
someone who works with clients, this is
massive because what does this mean? If
I've pretty much codified everything I
do into a skill, well then I can give
this system to someone else on my team
who should be using claw code but never
will and now they can use it. Same thing
with clients. You can set the same exact
system up for other people. package it,
sell it, force them to use it if you're
on your team. But they don't even have
to use the terminal because when we
eventually go into the dashboard section
and we look at something like this, you
know what we're eventually going to do
is we're going to turn all these skills
and automations literally into a button
you have to click and anybody can do
that. So that's step one of three of
creating the Aentic OS. It is the
architecture and it's the most important
and if you do nothing else, you'll get a
ton of value out of this. Now, step two
is the memory layer. And we are going to
be using Obsidian for this because it
doesn't do us any good to have all this
stuff running in an operating system,
yet we can't go ahead and look at what
we've done in the past or store
information. And Obsidian gives us a
very simple way to do that. Now, the
great thing about Obsidian is it's free.
I put out a bunch of content on Obsidian
and how to set up. So, definitely check
that out if you want to do a deep dive
for it. But the thing with Obsidian is
if we get very reductive, all Obsidian
really is is it's a nice layer, a nice
interface for us to be able to interact
with Markdown files. If you just
download Obsidian and you run cloud code
inside Obsidian, it's not going to do
much for you. It's how we set up the
sort of file structure within Obsidian
itself. That's important. That's how we
actually derive value from this piece.
By now, you've probably heard of the
Carpathy Obsidian quote unquote air
quotes here rag system. And that's kind
of the structure we're looking at here.
And again, I've done content on this as
well. And this is a great place to start
when we talk about a memory layer for
our system. So the way Obsidian works is
when you download Obsidian, you
designate a single folder as the vault.
It doesn't have to be called the vault,
but in this case, it is. It's literally
called the vault. The vault is where
your claentic OS is going to live. So if
you want to use the OS when you start up
your terminal, you're going to need to
be in the vault. Now, how you set this
up is ultimately up to you. The great
thing about everything we covered today
is it's customizable. You don't have to
do it exactly like this, but it's a
great template to start with and you can
tweak it as you see fit. But the way
Andre Carpathy lays it out is we should
really have three subfolders in the
vault system. We have the raw, we have
the wiki, and we have the output. Big
picture, why does this work? Well, we
sort of have like one folder is sort of
the dumping ground. Whether it's us just
talking to claude code or researching
random stuff. This is like the staging
area. We then have subfolder number two
which is the wiki section. And the wiki
section is sort of this interary
intermediary piece where we take stuff
from the raw and we then codify it into
wiki type articles. So we don't just
have a bunch of random information
sitting inside of our agentic OS. Well
now we have a series of like wiki
articles. So let's say I did a bunch of
research about rag systems. Well, all
that research would go into the raw and
then claude code would create articles
that are actually detailed reports about
everything at research that would go
into the rag system wiki. Then let's say
we wanted to take those reports and turn
it into a slide deck. Well, that goes
into section number three which is the
outputs, right? So maybe we have a slide
decks subfolder which now has
information about rag systems. kind of
get what's going on here. The thing with
memory is a we use obsidian to kind of
control it all, but b the real value is
how are you going to set it up, right?
What makes sense for you? This is just
one way to do it. All you need is you
need something that makes sense. So if
we go back to, you know, sort of the
agentic architecture here, you could do
something where every single domain is a
subfolder. You know, everything about
research goes into research. Everything
to do with my AI agency goes into my AI
agency. Everything to do with sales goes
in the sales subfolder. It really
doesn't matter, right? It really doesn't
matter. There's no right or wrong answer
here except to say you just need
something that makes sense and you want
to use Obsidian because it's a great
middle ground between a full-fledged rag
system. For 99.9% of people, you don't
need even something as lightweight as
light rag. You don't need a vector
database. It's too much. And if you're
just using markdown files, cloud code
can handle something like this just fine
within the confines of Obsidian. Now,
the one thing you do need to do when it
comes to Obsidian and Cloud Code in this
OS is create a proper claude.md file.
Right here, I have a template you can
use. And what this is going to do is
it's a it's going to tell Claude Code
what the heck is going on here, right?
What is my purpose? How should I be
function functioning? What do you do?
What should Claude code care about when
we give it any prompt at all? Because
the claude.MD file for all intents and
purposes is pretty much appended to
every single prompt you give it.
Secondly, what the claud file is going
to do is it is going to spell out for
our agentic OS system how its memory is
actually structured. And if we tell it
how the memory is structured, well then
it's actually going to adhere to it and
it's going to be able to find what it
needs to find with less tokens and
ultimately give you a more efficient,
less costly system that not only can
claude code actually navigate its way
through, but you can navigate its way
through. Right here you can see my
structures. It's it's not too
complicated. I have an archive, content,
ops, personal, projects, raw, and wiki.
So it's somewhat of a spin-off of the
Carpathy rag structure. The point is it
makes sense to me and it's clear enough
to claude code in terms of how I want it
to be structured and where I want things
to go that it makes sense and that it
works. That's all you really need. But
you do need it. You can't skip the
section. This sort of memory system also
gives us the ability to track things and
therefore optimize them because if
everything's done in a vacuum, we never
know what really is working. So again,
everything is tied together. We need to
nail the memory piece. Now it's time for
the sexy part which is the Agentic OS
dashboard and the whole observability
system. What we are really doing here is
we are simply taking all of this, taking
the skills, taking the automations and
we're going to take each one that we
care about and we use and we're going to
put it here inside the OS. That's kind
of what I've done here. Each of these
buttons is either an automation I can
trigger with a click or a skill I can
trigger with a single click. So if I hit
something like deep research, you see it
populates the prompt right here. And I
just need to put inside an input. And
it's the same thing as if I took this
exact prompt and put it into claude
code. So if I put here claw. So if I
write in here claude code skills and hit
run, what's happening is it's now
starting another instance of cloud code,
but it's headless. It's like an
invisible version of cloud code. So it's
using it's just using the -ashp flag to
do that. And then here I'll get a whole
write up and just as if I wouldn't set
the terminal. That whole system of
turning skills into buttons. The real
value play for there is if you're doing
this again with team members or clients
because the truth is if you are someone
who is adept at cloud code and using the
terminal or maybe even just using inside
of something like VS Code or the desktop
app, hey, the idea of taking these
automations and taking these skills and
turning in the buttons sounds great.
Doesn't really do anything for you,
right? Because you're good enough at
this point. Like I can just get those
going. Like I I don't need that system.
But if you do any AI agency work, huge.
If you work with a team and they're just
like they're not going to do the
terminal, but you're trying to give them
the power of cloud code because think
about that, you are giving them the
power of cloud code. I could take
anybody, put them in this chair right
now, put them in front of the agent OS
and say do X, Y, and Z. Here's the
skills. They can do it. Like that's
there's real value there. But the second
piece of this whole like non- terminal
visual thing is the observability side.
And again, this is extremely
customizable. So right here I have stuff
related to usage like my 5-hour window,
my weekly window, the amount of routines
I've used for the day. I also have stuff
over here on the right hand side related
to recent changes to my vaults and
forecasts and things of that nature. But
this can be whatever you want. In an
ideal world, it's tied to, you know,
your sort of skills and things like
that. Like what do you wish you could
actually see inside the terminal? As
good as the terminal is, the terminal
does have some limitations. If we move
to a system like this, we can get around
those limitations because if there are
things we want to track, we can put that
here and it is literally one prompt
inside of cloud code to execute that. So
here's a look at that deep research
output. Gives me sort of the overview,
gives me a link to all of its sources
and also includes a link to where it
exists inside Obsidian. Now, in terms of
creating this dashboard, I have a whole
prompt for that as well. It's going to
look slightly different than mine when
you run it. And that's because at first
it's just going to be a lot of
placeholders because it's going to start
a conversation between you and claude
code where you figure out okay which
skills do you actually want tied to this
dashboard. Furthermore, what do you want
in terms of observability? Do you want
the usage limits? Do you want routines?
Do you want sort of forecast and update
of what's going on in your vault like
mine? Maybe not. Doesn't really matter
what you want because you can customize
it to be anything. And I think that
customization piece is so big,
especially if you do any level of client
work. But that's really it in terms of
the three steps. Step number one is
architecture. What do you do? Can we
break it into domains? Can we take the
domains into tasks, tasks into skills,
skills into automations? Step number two
is the memory piece. How are we going to
set up our Obsidian vault so that not
only does Claude code have a clear path
for where data needs to flow, but so you
have a clear idea of where data needs to
flow and where it is. because it's not
enough for just claw to figure out
everything. You need to be able to
actually see what's going on. And
speaking of being able to see what's
going on, that is step number three,
which is observability, which is one
piece, you know, being able to do things
we can't do inside the terminal. But a
second piece is empowering members of
your team or clients by giving them the
ability to execute these skills and
automations with literally the press of
a button and they never have to touch a
terminal. You put all that together and
you get a clawed code powered agentic OS
that you can customize to your heart's
desire. So that's where I'm going to
leave you today. As always, let me know
what you thought in the comments. Make
sure to check out Chase AI Plus if you
want to get your hands on the Cloud Code
masterass as well as my exact Cloud Code
Agentic OS. And besides that, I'll see
you