How to Turn Claude Code into an Operating System with Carl Vellotti

Cloud Code just hit two and a half billion dollars in annualized revenue in nine months.

It is the fastest B2B software product ramp in history.

So why are most people still using it like a chatbot?

Everyone says it's not about prompt engineering anymore, it's about context engineering.

Why are we so obsessed with managing the context?

What happens if you hit the context limit?

Where does that data actually come from and how is it calculated?

Is it a major area where people just do not trust AI?

The caravalati has turned Cloud Code into a operating system.

Native skills, data visualization, and sub-agents managing content.

When you have a sub-agent like this, what's awesome is that instead of doing that in its main session,

it has spun up basically a clone of itself that is now doing all that work.

So what I think is so amazing about this skill is that it actually doesn't give

Cloud Code specific new abilities.

All it is is it's just a really good prompt.

This is how most people use Cloud Code, type or prompt, and get output.

Caravalati flipped it.

He built skills that interview through a framework before building anything.

When you understand how Cloud works, it makes it feel less like you're just prompting Cloud

and watching it, and more like you understand how it works and you're working together.

Free of the paid plans of mobbing, arise, relay out, dovetail, linear, magic patterns,

deep sky, reforge build, descript, and speechify.

So be sure to check that out at bundledorakashi.com and now into today's episode.

Open AI just acquired OpenClaw and Thropic-released

co-work, and the question on the top of everybody's minds is, does Cloud Code still matter?

Caravalati has been knee-deep in these tools and he says the answer is yes.

His last two episodes crossed over a million views of class platforms.

And if the first episode was the beginner version of Cloud Code and the second episode was the

advanced masterclass, today is the operating system layer.

If you're already an 80 out of 100 on Cloud Code, we're going to bring you to a 95 out of 100.

And if you stay till the end, you will understand context management,

creating sub agents to manage your context for you, auto triggering skills,

and building an operating system around it all. So let's get right into it.

The question on the top of everybody's minds is,

should they still be using Cloud Code in a world of co-work and OpenClaw?

What do you think?

Yeah, so that's a lot of these new tools. They're amazing.

Cloud Code was the first kind of the most powerful where all of the

everything else is built on top of.

You have tools like co-work, which is basically it's a UI that builds on top of Cloud Code that

tries to make it easier to use. And it's good for the use cases that it does have

of like managing files and things like that. It is a good tool.

But ultimately, it is built on top of Cloud Code. So all of those features,

they exist in Cloud Code first in a more powerful way.

And then they kind of get constrained by co-work.

So if you want the most power just to be able to do things and do work,

Cloud Code is still the number one tool.

And I would say with OpenClaw, it's a lot like Cloud Code where essentially it is a way that you

can connect to Cloud Code or a Cloud Code-like service from other channels. You can have it running

all the time. It's really good for monitoring and tasks where you really can let it run autonomously.

But if you need to be in the loop and you need to be in the driver's seat and you really want

the most power in the tool, then you don't really do that in OpenClaw. You do that with Cloud Code.

And then you can set up OpenClaw to do some of that monitoring type of work.

But if you need the person doing the most powerful work that you can,

you really have to be in Cloud Code.

Yeah, for product managers where you need to be the driver's seat,

AI still can't do the thinking for you. Cloud Code is still going to be the tool of choice.

OpenClaw is really cool for living and having the heartbeat feature and being able to chat with it.

But Cloud Code is still the most powerful.

Both you and I have been living in Cloud Code pretty much eight hours, ten hours a day

for the last six to eight months. And we've encountered four major friction areas

that we're going to help people solve in today's episode. If they listen to the whole episode,

what are they going to learn? Yeah, so when I kind of look at our first two episodes we've done,

we did a, we did kind of an intro. We did advanced. And I would consider this one the mastery course

where you're really good at using Cloud Code, but there's still another level deeper that you can go

to solve the biggest problems that you might have with Cloud Code. So the first is just context

management. How can you make it so that your context window doesn't fill up so fast and then

you have to wait and compact and then you do a couple more messages and it compacts again.

So what are some strategies that you could really manage context to use Cloud Code just way

more effectively and not have to wait as long? The next one is just figuring out how can you use

skills to shore up other major weaknesses of Cloud Code. People will say Cloud Code is not very good

at research. They'll say it's really not that good at UI design. They'll say that it really can't

design slides and things like that very well on its own. Most of the time what you need to do is

you just need to figure out how can you provide the tool that Cloud Code can use to do those things

better. So just shoreing up all of those weaknesses with skills. And then we'll answer one of the

biggest questions that people have when they're working with AI, which is how can you trust the

results? For a lot of people, they don't really need AI to just be able to do tons of mass-produced

work. For product managers or people with a really accountable for a very small number of

documents, they don't need lots of work to be done. They just need the work that they do do to be

very high quality and very trustworthy. And so today we'll look at an example of how you can do that

with data using Cloud Code where you can know exactly how it got its answers and that you can reproduce

them deterministically every time. And then we'll put all of this together and it's kind of like

last major question that people have about Cloud Code is, okay, I can do all these things,

but how do you actually put it together in a cohesive system so that when you're using it,

you're not just kind of having files go all over the place. So really today I would say is taking

all of that Cloud Code knowledge and Cloud Code uses that you already have and just taking it to

the absolute next level with giving Cloud Code its own skills inside of a really strong operating system.

I'm so excited for the science can improve my own Cloud Code usage. So show us the sauce,

how do we handle context better? Yeah, so the first thing to do and this is this is kind of like

a fun little trick that I just recently learned is you can actually there's a lot of different elements

of the Cloud Code UI that you can actually customize. And so right here and just kind of a quick note on

the setup, we're in cursor here, but we're not using any cursor features. We have Cloud Code open

here on the side and we're using the Cloud Code CLI and we'll just use that for this entire podcast.

So the first thing I really want to show is there's something that you can customize calls the

status line. And so you can actually have Cloud Code show you how much context you've used at any

given point throughout a conversation. And what's nice is that you really get a much better sense of

how is your context filling up? What types of requests are filling up the context? Where is it

getting eaten into if you just set this up? So the first thing to do is just set up a nice

status line. And it's incredibly easy to set up the status line. There's a slash command called

status line. And I'm just going to go ahead, I'm going to go ahead and just put in a really nice one.

So we're going to there's a bunch of different things you can include in this status line. So here

we're going to have it show us what model we're using right now, what folder are we in and then

make a little UI for the amount of context that we've used so that we can visualize it as we go.

And it's almost like a tiny little piece of software or tiny little UI where you can have it like

when you're when you have a lot of context left it's green when you have a medium left it's orange

and then when you're almost filled with your context window and Cloud Code is about to compact it turns

red. And this is something I discovered from another plugin we'll look at later. But it's

incredibly easy and you can literally do slash status line explain what you want and cloud will build

it into its UI right there. So we're about to see that. We see here it spun up its own custom

sub agent called status line setup and is now going going ahead and building that.

And if you see just a second ago we had nothing under here and now we have this status line that we

just described. So we have it tells us that we're using opus 4.6. We're in this demo file that will

be available to anybody who watches this video and then this is how much context we've used. So

we're only at 20% and we're in the green. So number one thing setup setup a nice status line

and then that will help you really kind of learn about how to use context as you put in different

prompts. And for people who maybe haven't encountered this issue right why are we so obsessed

with managing the context what happens if you hit the context limit doesn't it just auto compact

isn't there no problem really. Yeah that's a good question. First of all I would say the

compacting is kind of one of the worst things about using cloud code. Especially if you give it

like a long task like hey can you go research this thing for me that it runs a bunch of web searches

and every single time it uses a tool call and every time it reads a web page it's it's eating into

that context window. And so if you have a bigger project where you have you're working with a lot of

files at once it's easy for this to get to 100% with just like five messages and then you're waiting

like you're waiting a long time you're waiting you know two or three minutes for it to compact

and it can just really give it a way of your flow of using the tool. So avoiding that is for me

personally that's why it's helpful to kind of have the context get used up slower but the real kind

of the real even like bigger and more more important lesson is that as I've been using AI more and

using cloud code more I knew this before that everyone says it's not about prompt engineering anymore

it's about context engineering but that's just absolutely it's kind of the golden rule of using

these AI and using these really powerful tools they are able to work with the information that they

have and so you want to make sure that they're only having the information that you actually need

them to have but that when they have need that information it's kind of everything that they could

possibly use and so you can if you're limiting the things that they don't need then you provide

a lot more room for you to include the things that you do need and the overall quality just

really dramatically goes up. Exactly and I think that there's still this phenomena of context rot

which has been measured which is that as you get longer into the conversation the quality

degrades and as you use up your context window you're going to see that happen so you actually want

to give a minimal amount of context to actually have it understand what you want it to do. Exactly

exactly here's the dirty secret about prototyping you spend two weeks building a prototype you

validate your assumptions engineering loves the direction then what happens you throw the whole

thing away bolt changes this completely when you prototype and bolt you're not building throw

away markup. You're building real front end code that integrates with your existing design system

so when you hand it to engineering they don't throw it away they ship on top of what you've built.

I use bolt every single day I host my LAN PM job cohort on it and honestly I'm up till 2am

some days just vibing in the tool having fun and building that's when you know a product is good

when you're using it past midnight not because you need to but because you want to.

Check out bolt at bolt.new slash akash that's b-o-l-t dot n-e-w slash a-a-k-a-s-h

link in the show notes. Today's episode is brought to you by Ampitude. Replays of mobile

user engagement are critical to building better products and experiences but many session

replay tools don't capture the full picture some tools take screenshots every second

leading to choppy replays and high storage costs from enormous capture sizes others use wire

frames but key moments go missing creating gaps in your understanding. Neither approach gives you

a truly mobile experience. Amplitude does things differently their mobile replays capture the

full experience every top every scroll and every gesture with no lag and no performance

head it's the most accurate way to understand mobile behavior see the full story with Amplitude.

And so one of my favorite ways to do that so again this was just setting up okay now we have an

idea of where our context is so of course the you can always just do the nuclear op-new of clear

so that basically starts a new session so the most effective way and and I haven't used

in cloud code for months and months but I honestly only just realized in the last few weeks how

amazing sub agents can be for controlling context so as an example so right now one thing you can

always do is you can run let me get rid of this yeah okay one thing you can always do is you can

always run slash context and that will show you where is the context of cloud getting eaten up

and so right now we see I have a couple things already enabled so I have right if you go to the

top it gives you like your overall summary so here we have 16% of our context is used which is crazy

that's just I haven't done anything we just cleared so 16% is just eaten up for doing well for me

let's see what is taking it up so the system prompt which you can't really get rid of that's just

like part of cloud codes that's taking up 2% and then all of my tools that I have enabled right now

I have some mcp's some custom agents are there all of this together is taking up another 8%

and then I have a bunch of these like I right now I have cloud and chrome enabled so this is one

thing just right off the bat do you have a bunch of stuff that's turned on that you don't actually

need and then you could go through and and turn it off so that is like the quickest way to just

make sure that you're not eating up all your context yeah but let's let's go through an example here

so let's let's just give cloud a task where we're going to see it eat up a lot of its own context so

we just saw right now to start this off we're at 16% so I'm just going to run a pretty normal

command here which is research the top five cloud code tips from this week so when we ask it to do

that actually when I do have one tool turned on for research which we'll use later but I'll turn

that off for now okay so let's go ahead and run that again so research the top five cloud code

tips from this week and so what is cloud going to do here well it's going it has a web search tool

and it has a web fetch tool okay it's getting ahead of me here it's a what is doing here and what

is decided to do is it's decided instead of running that search on its own which is oftentimes what

you do or if you if you ask it to do a task without telling it specifically to use agents then it will

just start running that prompt and then it will kind of do all of that in your chat session and it

will eat up a lot of that information or a lot of that context window that it has just doing the

searches and then just getting the results and then summarizing them yeah but when you have a when

you have a sub agent like this what's awesome is that instead of doing that in its main session

it has spun up a like basically a clone of itself that is now doing all that work and what we're

going to get back here in our main session is we will just get the summary of it so you save your

main session from having to do all those tool calls and read all the information and then just get

the summary and so that right off the bat if you can remember to use cloud or tell cloud to use

sub agents to do its work instead of having it do it in its main thread for many things that will

automatically just save a lot of its context because it's just getting the result instead of all

of the work to get that result and to implement this agent I believe it's two parts right in your

cloud MD you tell it what you just told it use sub agents to use your work and then you create the

sub agent the research agent correct so yeah great question so cloud can do two things one it can

either just make it on the fly make a new instance of itself and give it a task which I think is

what it did here versus earlier when we saw it do that the status line that's like a dedicated

sub agent that is already sort of defined of how it works and sometimes it can also use those so

those both work but if you don't want to take the time to like actually define a sub agent this

will work for even just like on the fly tasks as well awesome okay so here what's cool is we have

the result here and let's go ahead and look at our context from when we started we had 16 percent

to begin with and now we're only at 16.5 percent so if we did this type of if we did this type of

thing without doing that and when I was texting this on my own it would fill it up to 25 percent

which is a lot for just a basic web search right and the other thing that's really cool is that

we saw it run this search and it kind of reports back on exactly what it did it ran 10 tool uses

and it used almost 30,000 tokens so all of that information is saved from our main session

because we had it use this sub agent nice yeah so that's a good one um and this is where I would say

it uh it really starts to feel when you can kind of understand how does cloud code work and where

arts weaknesses it should dynamically create these agents and we actually did see it do it here

oftentimes it will not do it when it would be a good idea and the kind of like mental framework

to have in your mind is do you need this main session to do all the work and so sometimes if you're

like coding something or you have like a specific question it's helpful for it to have all the

context of like all those files so that you can ask it something directly and it doesn't have to

see what it's agent state and then pull that context in um but here when you understand how cloud

works you can kind of tell it how to operate itself which really just levels up and it makes it

feel less like you're just prompting cloud and watching it and more like you understand how it works

and you're working together love it so I assume you could just say something like use a research sub agent

in the prompt if you want to force it or it hasn't done it and it's doing the context filling up

way is there a skill or something we should be using to further encourage cloud to use sub agents

yeah great question so in fact I do have in this uh in this file I have a skill called spin up

which uh oh it's kind of the little the lingo is that it spins up at sub agent so sometimes when

I'll be giving it a long task I can say you know research all the top cloud code creators

in the world and I'm sure you would come up and then we can you just add to the end of this spin up

so instead of saying please make sure you'd use dedicated sub agents we have this rule here where um

basically it'll run the skill of spin up and then it knows that it should run uh parallelize that

and use a sub agent instead of doing it itself so that's just kind of a shortcut to make this

quicker nice can you just show us the rest of the spin up skill once we execute that yeah so let's

go ahead and run it here and then I'll make this bigger um so spin up so set up a new product uh

sorry what this says when the user runs spin up you help them configure oh sorry this is actually not

quite what we would want um okay so this is a good opportunity so let's let's stop this so this

spin up command I think uh has some stuff that we don't want um for people who are wondering how

you stopped it you hit yeah great question so and yeah and this is where you just when you really

get familiar with the UI so escape we'll stop it and then one thing you can always do is you can

always hit escape two times and then that will give you all of the messages that you've done

and this is also actually another way to like kind of save context if you if you ask a question and

you realize it was the wrong question instead of having that in the memory or if it did a bunch of

stuff wrong you can always just roll back to earlier and then that will just get rid of all of that

and it just puts you right back in there with that exact same uh sort of wherever the context

window was at that so anything that you roll back and you erase is literally completely gone so

you have to be a bit careful um make sure that you do that wasn't something you maybe wanted

but it's a good way to kind of continue to conserve your uh your context window so I think we're

gonna fix the spin up age skill now and show people how to edit skills yeah yeah let's do it so

we know what we can do we'll just go ahead and delete the skill because it actually has some

stuff that's a bit wrong so we'll just delete it and we'll show how can you make a skill with

clock good so please make a new skill that helps me tell you when you should use um dedicated

sub agents instead of the main session to preserve your context window nice and you

see how easy a natural language it is skills is the unhawk like Carl said whenever you feel like

there's a weakness in this case there's a context management weakness spin up a skill you know

it's going to write a skill for itself yeah exactly and so uh now it's looking at the existing

seal structure it'll make sure matches the format and um I and throughout like recently made a nice

change or you used to have to restart cloud code for to pick up skills uh that you made but now it'll

actually it should just pick it up directly in here and I didn't tell it what to call it so it's

going to come up with its own name oh yeah it won't be slash spin up anymore yeah I think this

is a now good time to warn people don't download too many skills from random skill marketplaces

um especially if you're probably running cloud dangerously skip permissions there have been a

lot of malware and prompting junction attacks in those skills that people have been analyzing online

so it's generally best if you're going to get a skill get it from me or Carl somebody you super

trust or just create them yourself yeah exactly your own skills are good and then we'll look at one

other marketplace that for sale recently came out with um that's uh it's maybe not perfectly safe

but it is a pretty well-validated marketplace but yeah if you make them I think most of the benefit

from skills is like you know your own workflow once you've seen that you're repeating something

multiple times then it's time to make a skill and it will be customized to your exact project

mm-hmm so let's see it came up with one called context guard here but before starting any non-trivial

task evaluate whether it should run in the main session or be delegated to sub-agent so let's

try this again so we had our question from before which was research the top five cloud code tips

from this week and then let's ask it to use context guard context guard there we go and then

you always in the last episode we sometimes had trouble triggering skills it's best to just have

this invocation with a slash command or use context guard skill in your prompt so that you don't

run into the issue of it sometimes not using it yeah exactly now I did figure out how to fix that

so we'll we'll cover that we'll cover that quickly but the the most surefire ways you know

know your workflows know the skills that you have and then um yeah just use them when you need them um

okay so it looks like it went ahead and did it it said applying the context guard there's a web

research task high context multiple searches page reads delegating to a sub-agent so now anytime

that we need to do this type of thing um you can just run this uh run this command context guard and

that will preserve your main session a lot and again the rule is do you need the main session to know

it no we don't need it to like see what all of the web results like web search results were we just

need to know what the final output is this is fire so how do we fix the skill invocation issue

we'll get to that in one second um the other things to show that are good is so while this is

running one thing that's cool is when you have a sub-agent running is here it says use control

beta run in the background so I'm going to do control B and what that will do is it actually now

if we see down here it says um one one local agent and so we can go and see what that's doing

but now it's kind of nice because we can actually just continue our main chat while that's running

so that we don't have to wait for it and so this is really nice if you have like a bunch of stuff

running in the background that you don't you're not like immediately dependent on the results

you can have that agent run in the background and then you continue your conversation

and then as soon as this local agent finishes it will kind of inject this up into the chat

and then cloud code will read what it what it came up with nice and you just clicked on the local

agent to see that right uh so I just navigated it down and then it entered uh down and yeah cool

and so here we see what it it's kind of cool to you can see like what was the initial prompt that

cloud gave to it and then we can see it's fetching and searching when it's done the next thing I

want to show is my absolute favorite cloud code feature it's my it's like my absolute favorite

I like sub agents I think they're probably my second favorite feature my absolute favorite feature

of cloud code is the ask user questions tool have uh do you have you used it you find yourself using it

actually no oh really okay this is a feel like I'm missing out I feel like this is my love

recording these episodes so I can learn the latest alpha yeah the ask user questions tool is so

awesome so what we're going to get back here whenever this finishes it's being very thorough um

is we'll have this big list of cloud code tips that it found from the internet and then

in in in you know let's say that we wanted to implement some of those into our uh system

then normally we'd have to read them and we have to say okay can you tell me about this one can

you tell me about this one um or how we how could we implement this so we got these like five top

cloud code tips so now what we're going to do is we're going to say please use

your and then the magic phrase here is just ask user questions I don't think it has to be in one

word but that's kind of like the official way that it is so ask user questions tool to help me see

if we should implement any of these and what's so cool here is that cloud will now go through that

and it will dynamically come up with a list of questions to ask us but it will be in like a new

custom UI within cloud code um so what we see here is it says which of these cloud code tips would

you like to implement and so it's giving us these in like a UI so we can say okay I want this one

and I want this one and then when we hit submit it will now have that in its uh in its memory and it

will be able to go through it directly this tool I just use it all the time like if you are coming

up with the list of requirements for a feature then you can say please use your ask user questions

tool to grill me on all the possible requirements for this uh spec so that we can fill all that in

and what's so awesome is that this will kind of take it from where cloud code is the main reason

that people don't like the output from AI is because there's just so many assumptions and so many

things that it gets wrong because it really didn't have that in its context but if you have it

ask you it will predict like where are my weaknesses that I have or where are the assumptions that

I'm making that I need from the user and it will ask you questions and if you if you really make it

strong like a strong prompt like please ask me as many questions as you possibly can it will just

keep asking you know it sometimes it'll be like 10 or or 12 questions or something uh I know one

person on twitter said that it asks them 67 questions so they probably had a very vague starting place

but it's just uh it's just this really nice way to be able to work with cloud directly in this session

rather than uh it's otherwise it's actually pretty hard to answer questions it might do one at a

time or might ask you a bunch and then you can number them in the chat but this is this is beautiful

UI that it will do right here in in cloud code which I I love this feature hmm I like it so it's

sort of like that idea that you're not engineering this massive prompt or building this massive skill

to solve the problems for you you're saying please ask user question if you need clarification

yeah exactly um and yeah and you can use it in all different kinds of way you can say um

hey I have the spec user ask user questions tool to um like shore up any areas where you think

might be uh unclear or we're about to start this project user ask user questions tool to ask

them clarifying questions think things like that so really just like anytime it would be helpful for the

AI to get more context to help you have a better output use that tool and then you can just do it

right there and it's it's just it's just so nice it's just right there in the chat um better than

anything else I've seen I would say it's one of cloud codes like most probably creative features

amazing so what other skills shouldn't people be creating yeah so uh I would say in general whenever

you're kind of like going through your workflow and you realize you're doing the same thing

multiple times that is a great time to add a skill the other main time I would say it's really good

to figure out how can you build a skill or how can you find a skill is areas where you think

cloud code is really weak then you might be able to just come up with like a prompt or skill that

gives it the tools or just the knowledge it needs to do much better work so an example here um if

you type slash plugins it will show you kind of like the overall cloud code marketplace the the

the kind of most the most safest possible skills that you can have or of course cloud's own official

plugins one of the most impressive of all of the skills I think that people have talked about is um

so cloud has they have 56 of their own plugins is this front end design skill so you know uh it's

very commonly talked about that uh hey I always makes this sort of purple gradient generic kind of

UI right if you if you just say please make me a landing page like this and I actually have a

really good example um when we uh let me let me open the browser here when we uh did our first

episode I kind of did like a small lead magnet um so that people could get the the code the like

code that we did from that and then I I now have a cloud code for everyone is my main thing but I had

the cloud code school so this is a real example I actually ship this this this is a real wide page

right now um this is the kind of output you get if you say hey just make me this and this is just

incredibly AI right yep screens written by cloud yeah you you just know but I also I for our next

uh kind of like for our next version or our more advanced one I had I had it use its front end

design skill and this is what it came up with where it's just it's just much cleaner and nicer

and feels you know it's it's it's still uh you know still a classic kind of web page but now it just

has so much more personality in this than the first one so I would say this is just a perfect example

where okay I think AI is bad at this well maybe all you actually need is a skill and what's cool

about this skill in particular so let's go ahead and look at it um we'll have cloud code open it

up for us um there's a couple different ways that you can approach skills so what I think is

so amazing about this skill is that it actually doesn't give cloud code any like specific new um

abilities all it is is it's just a really good prompt um I'm gonna have it open it for us here

in cursor one thing that's interesting is when you install a plugin or you install something from

the marketplace it uh depending on how you have it configured um it's not actually in this repo

it's kind of like at the computer level so we're not seeing front end design over here in skills

it's like a couple levels back um but this is this is what we have here so it just shows like uh this

is what all skills have which is their name and then their description and when they're supposed

to be used um but this is just the prompt the anthropic has come up with to tell the AI just

better rules for how to do front end design so like think about the purpose of what you're building

make sure that you have a clear conceptual direction um here's the aesthetics and it basically

tells it to don't be AI instead follow these rules and so I think it's it's good just to show you

can have an incredibly powerful skill that doesn't have any mcps or apis or any code with it

just wrote really good prompt that you perfect over time can make a really really good skill

although skills with tools are pretty powerful right yes skills with tools are definitely more powerful

so that's what we'll look at um next today's podcast is brought to you by pendo welcome to the

SAS plus AI agent era where every product team no matter the size can build world class experiences

meet pendo AI agents virtual teammates that read your product data chat with users and take smart

in that action so you don't have to with agent analytics pendo shows exactly how those agents drive

adoption complete tasks and even cutchurn no extra engineering lift fully sock two and hip

already and because pendo's behavioral insights sink straight back into your bi stack you get AI

ready data to fine tune models improve ROI in one place smaller team bigger ambitions you no longer

need an army to deliver software your customers love grab early access at pendo.com slash akash

that's p-e-n-d-o.com slash a-a-k-a-s-h

today's episode is brought to you by nia one in tech buying speed is survival

how fast you can get a product in front of customers decides if you will win

if it takes you nine months to buy one piece of tech you're dead in the water

right now financial services are under pressure to get AI live

but in a regulated industry the roadblocks are real nia one changes that

their air gaped cloud agnostic sandbox lets you find test and validate new AI tools much faster

from months to weeks from stuck to shit if you're ready to accelerate AI adoption check out nia one

at nia one.com slash akash that's n-a-y-a-o-n-e.com slash a-a-k-a-s-h

I hope you're enjoying today's episode are you interested in becoming an AI product manager

making hundreds of thousands of dollars more joining open AI and an entropic then you might

want to do a course that i've taken myself the a-i-p-m certificate ran by open AI product leader

mcdad jaffer if you use my code and my link you get a special discount on this course it is a

course that I highly recommend we have done a lot of collaborations together on things like

AI product strategy so check out our newsletter articles if you want to see the quality of the

type of thinking you'll get one of my frequent collaborators pavel hern is the build labs leader

so you're going to live build an air product with pavel's feedback if you take this a-i-p-m certificate

so be sure to check that out be sure to use my code and my link in order to get a special discount

and now back into today's episode is there's kind of two ways that you can power up your skills

the first one is just you make a skill and in that skill it tells cloud to use like official

tools so we're we in this repo i have one a skill called web research and so

cloud if you just have it do a general web search like we did earlier in this demo where you had

it look up the top five um cloud code tips from the week those results that cloud code gives are

just notoriously unreliable um one it's basically just running google searches and it's just

grabbing stuff from the first page and i think you kind of know if you're just searching

stuff on google and you're clicking the first links you have absolutely no idea if those are

actually good links i think uh pre-a-i the internet was really starting to feel just like so much

SEO generated slop even before there was a-i-slop and uh if you do you really want that to be in the

context window for cloud so i would say this is another example of where people say oh you can't

really trust cloud to do reliable research well again this is an area where if you just give it

better tools it can actually do better research and so in this skill basically we have it connected

to two tools one is a an mcp called um tavoli i'll zoom in here um cp uh called tavoli so this is a

it's really good it basically is just like a much more powerful almost perplexity type of search

um that gets a much higher quality results than just a classic web search and so here we're

turning it on it's uh very generous free tier if anyone wants to try it and then what we also have

in this um skill is we have it uh connected to something called fire crawl which fire crawl basically

is once you once you have a url that will scrape it and get really clean markdown and so it's a

nice way where normally when you go to a website and cloud looks at it there's a bunch of extra html

like maybe javascript and things like that fire crawl will just get just the sort of like raw

information that the AI actually needs without all the other stuff and um one thing that's cool about

this is that um fire crawl is actually the way i have it set up is actually not an mcp so if we look

at the mcp's i have set up here um mcp's are good but as we saw earlier when we were just looking at

our context window they eat up a lot of context just right off the bat like if we look at our context

we see that um tavilly is taking up like a couple thousand tokens just by existing

yeah versus well you can also uh install our cli so a cli is kind of it's interesting uh it's kind

of like an older technology it used to be the way that you would operate a computer in the beginning

with a command line interface and they kind of fell away of course with people wanting like better

uis for most things but ais are really really good at using command line interfaces and um essentially

what they are is it's like you have a tool and then you download it on your computer and so it's

just sitting on your machine and then the a i can use the command line directly uh just through

because we're basically in the cli here and so you have all the power of that tool just install

on them on your actual machine so that when the a i wants to use it it doesn't actually have to have

context just holding it in there it can just use that cli directly from your machine and so what

we're seeing is you know originally there was mcp's but i actually think mcp's are kind of starting

to be the less preferred way over cli's and most tools already had cli's and there's becoming

a lot more so for example if you've ever tried to connect the google workspace mcp um i actually

tried to do that on another uh podcast live and it's just it's such a hassle but there's actually

a google workspace cli and that's what for example open claw uses so it's just way more reliable

than using an mcp because it's just on the machine and it's easy for the claw to figure out how to

use it and i think what we're going to see in the next over the next year is just a lot more cli

tools because ai are so good at using them yeah undercarpathy said to himself like you should

prefer a cli connection and i think the hierarchy is basically mcp at the bottom because it eats

up so much context then api cli at the top and funny enough cli is basically just usually a

wrapper on top of the api but agents like to work with cli's yeah exactly the other cli's i would say

are just awesome um github cli i would say basically mandatory if you're really doing anything with

github the cli claw is just aggressively competent at at the github cli it's it's amazing and um

the versel cli is another really good one where um if you want to deploy your app then you can

it can check the logs it can configure your environment variables um those two if you're like doing

any vibe coding if you have the github cli and the versel cli show much easier so much more powerful

i think this is one of the most underrated hacks if you take anything away from this episode stop

using mcp's start using cli's yeah and it just literally if you just if you just say hey clawed

does the cli for this exist more often than you'd probably guess that the answer is yes

and um hero and and and just download that and use that because it's just it's just so powerful

so what i did is i went ahead and ran our web research which uses tablet to find stuff and then

fire crawl to kind of scrape the pages and um that's just so this is again a really good way

to shore up that web search is not that good for ai but if you give it access these tools it can

be way more powerful but then i have those wrapped into a scale amazing so we covered frontend

design web search i think the other thing people talk about is making slides yeah so another area

where if you just say if you just tell clawed um hey can you okay if it's something web pages are

i think easier for a cloud to understand there's tons of web pages in its data so it kind of

knows what they're supposed to look like um but if you ask it to do something like make a graphic for

this or make a slide for this then and you look at his result they're usually not that great like

they're usually not laid out the best there's usually like alignment issues that could be better or

like the space isn't filled very well so one of the best things that you can do and this is again

all across the theme of just okay well i'm saying that claw code is bad at bad at these things but

for example what a lot of people will do and you'll might find yourself doing this you say okay

please make a slide an HTML that covers you know this thing and then you may it makes it and then

you screenshot it and then you say hey can you fix this this and this and then it does it again

and you say hey can you fix this this and this instead of uh you doing that think can i give

clawed away can i give clawed go away to check its own work and that is just a huge unlock for

anything that you're doing with like visual design with ai is give it away to see its own work

and so what we have here is we have a skill called make slides and this is a bit of a bit more advanced

so so far we've had just words and then we had words telling it that it has access to a couple tools

this one actually has a code in kind of telling it how to use code in the skill so that when it

runs the skill it will now know that they can run that code to help it check its own work

so here we have our make slide skill um this uh it tells it like okay i want to treat these

dimensions i want us to have these layouts so this is similar you know to the front end design

skill we saw but what's new is that there's an actual build process so it's step one and it's telling

it that um like kind of the different types of code that it can use and it's saying hey you can

measure overflow so it's using a tool called puppeteer which is like a very classic front end

development tool so you can take screenshots of HTML pages just exactly as they look when they're

rendered and we're saying hey you have access to puppeteer use it in this particular way so it's

telling it like the dimensions that it should grab um and then it's doing a calculation here to see

does any does any of this text fall off the page and that's a that's a thing that if Claude doesn't

have a tool to check it to check that it can't really do it on its own but with a tool it can do

it basically perfectly and so that's what this that's what this skill does is just embeds that code

base tool directly in the skill so that when we say hey make a slide it will run these tools that

it knows it has access to so this is the implementation of the advice when I ask Carl the question

what skills should you make and he said well anything that's coming up in your workflow if it's

coming up that you're iterating on these slides by having to look at it build a skill and now you

guys are seeing the most advanced way to build a skill with the code in it yep and so here I said

using your make slide skill to make a single detailed slide for a presentation called from

watching collaborating kind of the theme of this and so now what it's gonna do is it's gonna go

ahead and create that screenshot itself calculate and then one thing I found is if you just say like

you must iterate three times before you show me it'll be much better than if you say oh just go

until you're done I would say this is an area where you really see AI just barely have like great

taste you know if you give it an infographic that just a tons of information on it they're like wow

this is so amazing but the actual content or the layout might be terrible so it's helpful to just

say hey you have to improve it three times and then it will find some ways to try doing that yes

and there's also this crazy phenomena where if you repeat yourself with your skills the AI does

better there was just a Google paper released where they showed that they're really just

pasting in a prompt twice helps and this is I've been using this in almost all my skills these

days I'll say after I execute it once I'll say go double check against this skill again and it

really improves it and so call this technique is a way to sort of encode that so that it builds it

into itself yeah that's super interesting I think I've heard that I've heard that called the

Builder Validator Pattern where like when when AI just runs its own work it doesn't really have

that like self-reflection to like really know if it did it like it tries to follow the rules so just

having it I've never heard of just running the prompt at the same time that's very interesting

but I have had it just like okay do this and then here's the rules that I was supposed to do

did it follow those rules in like the second pass and the quality just goes up so much so while

this is building can you show us how to auto invoke skills because I'm just on the edge of my seat

about this yes okay so this is the riskiest part of this podcast so last time I said that there was

okay well actually taking a step back the way that skills are supposed to work is if when we

look at this skill for example we have this skill and it says okay use when the user mentions

makeslides make a slide create slides presentation so it's supposed to just know from when you message it

that okay great the person just said makeslides so now I know I have this skill and I should use it

it doesn't really work that way and it's kind of just like a funny thing about clog code is this

that auto invocation of skills is really finicky and I think most people have seen that it doesn't

work one thing you can do like this most dead simple way is cloud md the skills that your AI has

access to yeah that does it actually does make a difference but then you're adding your cloud md

and it's kind of hard to like if you add a new skill you have to go back and update the cloud md

plus then you're also like eating up context for no reason um so the way to do it is with hooks which

is another thing that we covered last time um but then the demo didn't really work but I think it's

going to work this time I really heavily tested it so what we have a hook is basically

some sort of like thing that you can have happen around the whole cloud code workflow so it can be

when you send a message it can be when a message comes back it can be before compaction it can be

after compaction so if you just think about like all of the things that cloud code can do like just

the whole life cycle of like everything that's possible within what like runs a tool runs a web

search all of that you can add a hook before or after and that basically says okay this type of

thing has to happen an example would be maybe every time a new dot a new markdown files created it

has to have you know some formatting at the top for example so here what we're going to do is we're

going to use a hook um that okay so we're going to use a hook it's a user prompts submit hook so

basically every time I run a message then that's when this hook will fire and but we already have

configured before I uh type this is we have a script that runs and it just says okay are any of the

words and the thing that the user just typed in are those in the keywords of the skills that exist

in the skills nice and um this is nice because it's just a script so it's not it's not like uh

there are like there there would be a way to do it where you would have the LLM like actually look

but that's very slow whereas this is a script that just says if there is a match then uh I will

give it to the LLM and then the LLM can decide oh okay now is right time to use that or now is not

the right time to use that so what we did is we just added this hook and then what we see it happens

is uh the way hooks work is so we had the hook here but it wasn't activated because you have to put it

in your settings and so that was how I that was how we set this up so now with there is a hook on

user prompt submit so whenever this command is whenever this you know command is run user

prompt submit then run this code and that code sees was one of the words that I just put in

doesn't match a keyword of one of my skills the biggest question that PMs have about AI outputs

is how can I trust this and you've built some workflows that people can use to enhance that what

are they yeah so one thing I've realized is that for for product managers and people who you know

they have a few things that have to be right and they have to really be able to rely on a beta to

be right one of the biggest areas that people are just really concerned about is using AI to do data

analysis because on one hand it should it should be really good at that right like it it can run code

and you see I do all this other type of code stuff but for data analysis you really need the

result to be correct and I think it's an area where if you're not a data analyst and you don't

really know exactly how the LLM is is coming up with its results then you're going to be relying

on these you're going to be presenting these to people you're going to be showing your boss this data

how where does that data actually come from and how is it calculated is a major area where people

just do not trust AI but it turns out they're actually like the other things we've been talking about

this is a weakness but there is a sort of a tool or workflow that we can use to give Cloud

Code but we can get much more visibility in the Cloud Code process so that we can trust its results

more and so the best way to do this is this is something I've kind of been playing around with

more over the last few months is Jupyter Notebook so this is the kind of like standard artifact

that analysts will use and it's actually a really good thing to use within Cloud Code and the very

cool thing is that we can basically create a Jupyter Notebook which is just it shows what were the

exact queries used for this what were the results and I can visualize that all for you and the

really cool thing about Jupyter Notebooks is that a Jupyter file will render natively in cursor

or VS Code so you can actually just stay in the tool without having to look at it somewhere else

and it's honestly one of the like nicest types of things that you can have be displayed here

like right in your in your terminal or your IDE so here what we what we have is we have in our data

folder here we have survey responses so we have 213 survey responses from all different types of

people in this sort of like fictional company around how they're using this to do tool and so what

we're going to say is please analyze this data in a Jupyter Notebook and show me what we're working

with so just to start you can and this is kind of like a very small quick example of how can you

work with data in Cloud Code and so here it's going to go ahead and it's going to look at this and

it will just kind of show us what we're working with it's pretty hard to see CSVs there are some

extensions to make it easier to see but they're not great so it's kind of nice to just have Cloud

Code like show you what you're working with and right off the bat we have here we see this new file

has created this Jupyter Notebook and it's just showing us a very simple it's actually still working

here so this is the code yeah yeah so it's running Python and then what it will do is it's I

it looks like it has to install a few things to make this like actually render but what we'll

see is we'll see like an actual UI example of of what this code is running for us so we see that

it's kind of just getting the the columns and data and it will present that to us we're seeing

Cloud do some live debugging here yeah if you ever go look over your data scientist shoulder they live

in Jupyter Notebooks and so how do we add proof of work to our analysis that's really what we

want to do we want to create traceable analysis the Jupyter Notebook is solving that problem for

you exactly and yeah so now we see that there's this notebook it just got the columns it's showing

us like what is the overall shape so has this many rows with this many columns here's an example

of what some of those look like so what we're kind of just seeing here is what is a Jupyter how

does it work it's the code it's kind of like some example output and then it's rendering that

nicely for us but of course you knew much more sophisticated things you can and it's honestly

amazing that once you get more familiar with the types of data questions that cloud can answer

it's like you're working with a data analyst that will just answer any questions you want about

your data it will segment in an anyway you can do pretty sophisticated statistical types of analysis

all types of things that if you're working at a company getting access to an analyst time to ask

questions that sometimes you're not even sure like exactly what you want to learn or you're hoping to

learn or if it would be worth it to do it in the analysis that used to be something that had

your whole process you probably don't have that many analysts at your company long time for them to

look at it and you have to get it on their own research or data roadmap now you can just do a lot

of that exploration right here on your own and you can actually trust results so for the next thing

what we'll ask here is just show me the distribution of enterprise interest scores as a chart so now

we're moving from just looking at the raw data to now actually creating like a nice visual that

shows a bar chart of the distribution uh between these different groups so step one it'll help you

visualize the CSV step two it'll help you create charts let me see it running its code over here

and then it's going to really powerful mental model for cloud code in general is take the roles

that you work with you almost want to create versions of cloud code for those various roles that's

kind of what the front end design skill is doing it's taking the designer role it's trying to like

distill what some of that person is doing here we're trying to distill sort of what an analyst might be

doing yeah i love that that's a really good framing it's like what are the tools or thought processes

that these roles have and then how can we give those types of things um to cloud code so that it

is able to do stuff like that and of course it won't always be the exact same but it it approximates

it much more and that's usually good enough for what you need to do as as a PM at least to start

so we see now there's a whole other set of code here and then we have this nice distribution

wow and so just to kind of round this out as one example so we're going to have it do like a really

crazy analysis we're going to say show me a correlation heat map of all the numeric columns

satisfaction feature important scores enterprise interest and nps what patterns are about so now we're

going from just you know we know what we are hoping to get like out of the data um and now we're

having it actually do a much more sophisticated analysis and then also look at it and tell us what

it's noticing and this is where you can really become like a collaborative partner with the AI

um of course you're going to see the things that it's saying but oftentimes with this type of stuff

it's it's pretty good like off the bat um especially if you give it some of those like more

ways to think about what would be interesting in the data and if you're feeling like I couldn't

craft a prompt as good as Carl did think about creating an analytics manager sub agent and this

is your analytics sub agent and say analytics manager agent really good at formulating prompts for

the analyst and then the analyst goes execute if you create this sort of sub agent structure again

replicating what it would be like in a real company you can outsource a lot of the thing

to cloud code yeah 100% that that is a good way to do it you can have it like kind of know what

are a bunch of different types of analyses that it could do I think this is a really good example

of where like it's much more fun to learn these things because now there's an actual way that you

could immediately apply them so here we have this like awesome correlation roadmap I don't think

we need to go like too deep into it but this is it looks cool and if you if you knew that this is

the right type of analysis that you wanted to do then uh now we we have it here and what this type

of analysis does is it just shows correlation between things so like in the survey results often

did people talk about enterprise interest and security okay well that kind of gives us a sense

here um that like enterprise cares about security enterprise tears about team management enterprise

doesn't care as much about price right they're a little bit more price flexible and so this is

just one example of like a really cool analysis that like you know the analyst that you're

company I sure they could do it but it would take them some time um you're not even sure if it

would be the right thing to ask but now we have this like awesome analysis and there's all different

types of regression testing and all that kind of stuff where if you if you learn what those things

are now it's really easy to execute them and you can have a lot more confidence in that you when

you show your analyst or you show your manager here is where we got that data from and then they

can look at this and tell you if there's anything wrong with that rather than you know just having

no transparency into how the AI actually gone to that end result so we've put together all these

features for people context management skills sub agents hooks even Jupiter notebook python analysis

I think the biggest roadblock for people is like putting this all together into a system so how do

people build the right operating system for their cloud code setup yeah I would say this is something

that uh it's so the main the way the way is you kind of use it and then you you probably like

even here we haven't really been doing stuff in the system so every file that cloud has been

making has been getting kind of like dumped out here and then now we have to figure out you know

where should it go in the overall system so just figuring out like where should the context layer

live like where where is are the types of information that you want to easily be able to provide

to cloud code where does that live what are the different types and then the other thing is thinking

about okay well I'm not just going to have this be a static workplace where I'm just going to only

reference say oh hey in my knowledge folder like I have these different people I work with I have

like stuff about my company you're actually going to be creating new work as well

and figuring out where that should go so I'll just do kind of a quick kind of rundown of the system

that I have found works really well I'm talking to other PMs I think it's a good starting place and

of course you'll customize it yourself um so for things where you just want to be able to reference

that don't change very often having just a knowledge folder with some of like the key things that

you want to be able to say hey Claude um I'm having a meeting with David Chen who in this case is uh

we'll say it's the director of core it's your direct manager um these are the things that they

care about um how should I structure you know this piece of writing or things like that so just

keeping in mind like who are the people you work with or like different reference material

research having that and like kind of a static knowledge folder somewhere for meetings to go

and Carl's being pretty humble about this but actually putting in the time to build this guys

I'm not kidding it will 10x the outputs so if you spend the hour to add in this really important

context and then structure in this way he said the outputs you get will look nothing like the

output somebody else using Claude code is building and that's how you we talked about AI Slop for

a second right earlier that's how you avoid that AI Slop label yeah 100% and there's so much cool

stuff you can do with with this type of knowledge in here so one people love this people folder

which is like kind of like a little dossier about like different people at your company it

no one even ever has to see this right this can be your way that you communicate with those people

but there's um or what you've learned about those people but what's so cool is like now that

Claude code is becoming more central to all these you can connect to everything you could uh

you know granola which is the meeting transcriber I think uh sponsor of this show they uh

they have an mcp that connects um you can pull in your meeting notes so you could literally

have a workflow like you have a skill called like update uh people that would look at what did people

say in the meeting that you just have with them and then add notes around like what are the types

of things they care about or don't care about into their file and then when you go to draft a

message to them or you're thinking about something um related to them you have this like

really golden type of context from real meetings in here and that that that just provides such a

totally different level of information and specificity that you can give to these models then

just saying oh yeah I have my manager he likes you know Kirk communication or or something like that

exactly yeah so just having up somewhere for it to live so that then you can build on top of it

is really the most important thing um I will say the the so having your knowledge folders like

and meetings and stuff like that is helpful I'll say the other main one that I personally find is

the like absolute most helpful thing for me is I have a project folder and the way I use a project's

folder is anytime I'm starting any kind of new tasks like I'm preparing for this podcast for example

I'll create a new folder called you know product growth cloud code up three and then now anytime that

I'm doing any work like for example um like a real example for when I was preparing for this podcast

is this is our third episode on cloud code and so I said I have a I have my own um like transcription

there's actually a YouTube transcribing CLI so I said hey please grab the transcripts from our first

two episodes what did we cover what did we not cover and then it drops those into this folder

and then I say okay let's draft uh what could we do look at in this next episode that goes in this

folder and so you kind of have a place for all that stuff to live and what's so cool is that the next

time like let's say I leave cloud code or um I'm on a different machine or it's just another day

instead of having to sort of figure out like okay what was all the information related to that

project what you can do is you can just literally take this folder and then I'm gonna hold shift

and you just drop it in here and say hey we need to work on this board deck here's all the research

I've done for before get up to speed and then let's work on it and so the project's folder is just

it's just such a nice way to have everything be couched you know somewhere in your system

and then uh next time you're coming back to it it's all there and then you archive it but anytime

you want to go back to it you have all of the initial artifacts and anything else that you created

with cloud code all right there right in that project folder nice so I think it might be worth

people doing a one time download to build a project's folder right so like hey here's our linear

in our notion please build out my last five projects folders pull the initial PRDs pull the features

results right up and that's how you can practically implement this pretty fast yep exactly

and then just kind of like the very last thing to show like once you do have this all set up like

what are some things that you can do one I'll just show quickly that that people like a lot is you

can have like a kind of start standup command so what this does or uh yeah start standup skill

so when we go to our skills and we look at um standup what this does is it will pull in information

from GitHub it'll pull it in from our task folder it'll pull it in from our calendar if we had

our calendar connected it'll check linear it'll and then it'll put it all together for us I don't

have all of that hooked up right now um but it will look it'll use the information that it does have

available locally and so it'll go through and it will pull in all that information and all of

those tools and all of those skills and all of those things that you have set up from this system

you can just start to you know mix and match them and having it all in one place let's see you

just use all the stuff and I can completely different way so that it's just right there it has

all the information and needs without you having to go and check all those places you know one by one

and so when I say I'm living in cloud code all day it once you get to a certain point it's like oh my

gosh I do not want to have to leave cloud code like I do not want to have to go to check google

analytics for how my website's doing I really want to just be able to ask cloud because then I can

say hey how is my uh website traffic and can you compare that to the post I've made on LinkedIn

this week and that would be almost an impossible analysis to do if I was just clicking into those

individual UIs but when you have cloud code here set up and connected to everything and you have a

place for that information to go then it just becomes more and more compounding and more and more

powerful and that's something to be honest guys I haven't done so I need to do that right now

and what about your cloud MD file your goals MD what else just walk us through the rest of this

operating system how you set it up so that people can kind of get to your expert level fast

yeah sounds good so um the other ones that I would say the other ones that are good to have

yeah so data we like we were kind of dropping all of our data analysis into here um tasks

so just some and I would I would say that you know you you can connect um

cloud code to apple robiners or to do this or things like that oftentimes you kind of as you use

cloud code more you just kind of start to become like a little bit more marked down native I would

almost say and so I like just having a a file that just says okay what are the things that I'm

currently working on uh and then what are like other things that if I don't have time to work on them

now just drop them into this uh this other folder and so this is a good way when I just ran that

stand-up command it says okay these are all the things you're working on there's these are things

that are not done yet so having somewhere to manage like the work and then also a place to

house ideas that you don't have time to get to is really helpful um and then the other really

really uh the other important ones tools so this is where um for example here we uh we have our

meeting prep uh as kind of a tool so this is something where um what it will do is this one will

actually go through and it knows how to run the code in order to put together uh a meeting

preparation for me and so if I'm for example building my stand-up skill I can say you have access to

this tool um that lets you prep meetings or you have access to this tool that uh will pull metric

so for example I have a big script that will pull in like my beehive um news letter information

and it'll check my analytics and and that's much better to have as like a pre-built script that you

can then test and what's what's nice about having it in a tools folder is that anytime you build a

new tool or like a new capability for cloud it goes here and then you can in the future uh like include

in your cloud md hey you have a tools folder um use that to figure out like what access to other

things that you actually have uh and then the last thing that's just really good to set up and

keep updated is your overall cloud file um if you're not familiar the the cloud file has like a

really kind of like special use in cloud code which is that it's automatically in context all the time

so for example when we run context over here in cloud code and we see like what are all the things

taking it up um the cloud md will always be there and what's cool is it's not just there in the first

message it's there in the background for every message so this is the type of context you want

to just always be aware of and so here i have like a fictional company set up called grade flow um

and this is just like good to include things about how you like cloud to work with you

who you are what are you working on so that every prompt is kind of through a little bit of a um

like it's through a little bit of a lens of what you're actually working on rather than just being

generic and this is the type of thing where people love open claw because it is so has a much

personally memory about you this is like the very light very lightweight version that exist in

cloud code yeah quite a sole md file but i would say guys there's a lot of alpha in continuing to

iterate on your cloud md file every week every month every time you run into an issue with cloud

code pull it into your cloud md file and update that cloud md file we have covered a lot of stuff

Karl you have a lot more to at cc for pms.com at the full stack pm newsletter on your hilarious

instagram your awesome linkedin and twitter is there anywhere else people should be going to

finding you and learning from you. No i think you hit the main ones cc for pms is my free

cloud code for product managers course i have another version cc for everyone.com that is

just a more general version but covers the same thing the cool thing about those courses is that

their cloud code taught in cloud code so you'll say um hey start lesson and then cloud code will

actually guide you through a bunch of stuff for example that i kind of showed you today and then

my newsletter the full stack pm those are the places you can find me amazing do check them out do

subscribe and like and comment if we should have them back another time i hope i hope we see

some likes and comments i love being on this show amazing we love having you Karl thank you

so so much all right thank you bye everyone i hope you enjoyed that episode if you could take a

moment to double check that you have followed on apple and spotify podcasts subscribed on youtube

left a rating review on apple or spotify and commented on youtube all these things will help

the algorithm distribute the show to more and more people as we distribute the show to more people

we can grow the show improve the quality of the content and the production to get you better insights

to stay ahead in your career finally do check out my bundle at bundle.akashi.com to get access to

nine AI products for an entire year for free this includes dovetail mobin linear reforge build

descript and many other amazing tools that will help you as an AI product manager or builder

i'll see you in the next episode