In the month of May, I did 318
commits
with Cloud Code.
Now I did have some with some of the other ones, like, used a little bit of codecs, root code, and augment code, but the vast majority of my commits and the vast majority of the number of lines of code that I produced or
refactored came from Cloud Code.
It is phenomenal.
When I first started using Cloud Code back when it came out,
I actually liked it back then too. It was early,
but it had cost way too much money for me to be able to justify using this on a daily basis.
Now Cloud Code,
it's a CLI based coding assistant
that is really locked into the Anthropic ecosystem. So it's important to note, I'm a little bit nervous about being locked into ecosystems,
which is why I still really use and really love RootCode. And I think open source really is where I wish things like this would actually be.
But I think there's something to argue with how good CloudCode actually works
and the fact that they can give you this monthly fee
to allow you basically unlimited
unlimited use.
So for OS support, this is what's a big problem for me and still is today.
So they out of the gate support Linux and Mac.
Now
the reason that this is a problem for me is I am primarily a Windows user, and I know a lot of you would be like, why? Why are you using Windows?
And
part of the problem with that is
when I started programming years ago, I started in the game industry. And everything you do in the game industry with Windows based, that's just become kind of my native operating system.
And on top of that, I actually do games, so there is a dual purpose there. So I I do have a Mac.
I do dual boot Linux. I have a Linux computer to my right, but I prefer
working on a Windows computer. I know that is not normal or popular, but that is what I prefer.
So what I end up having to run for Windows in particular is I actually have to run WSL.
Now WSL,
it's actually gotten a lot better,
And I'm actually using Ubuntu with WSL. I know some people use Debian or some other flavors of it, but Ubuntu has been really good to me. And I can do 80 to 90% of everything that I need to with WSL,
and I have enough RAM and system resources to where that doesn't actually matter. So I'm just calling that out. If you are a Windows user,
you are going to probably have issues unless you are willing to set up WSL, and I know some people are resistant to that. So that's just worth noting.
Now on the pricing side, as I was putting together this video,
I actually saw that Kat Wu posted this. You can now actually use Clogcode a little bit on the pro plan. So what does that actually mean? We've got the pro plan at $20 a month. Now this plan is what I was on for the longest time.
And this is typically for users that are just working in the web UI,
but now you can actually come in and at least try out Cloud Code.
I'd recommend doing this. This is a massive, massive thing for them.
What kind of limits you get? I bet they're gonna be very tight, to be honest with you. So I wouldn't expect to be able to do a lot, but you can at least see how it works for you.
Then they have a $100 a month plan,
and this is the max five x plan.
I've actually
just switched to this for this upcoming month because
I really do wanna be able to use some of my other coding assistance a bit more and not feel like I'm paying $200 a month
and I have to use ClawCode.
I do love it, though.
And I if I wasn't in the position that I'm at where I wanna test a bunch of different coding tools and things like that, the $200
max, I think it what is it? 20 x or 10 x? I can't remember exactly. But it's some x in here. I never hit a single limit on it, and I literally was running multiple instances of clogged code. So
just something to note here, these plans are phenomenally
priced.
Because when I was early on using Cloud Code,
I would burn $20.30
dollars in a day,
and that wasn't even me, like, aggressively using it, just using the API. So just noting that that it's probably worthwhile considering
jumping up to the $100 a month plan if you find yourself liking CloudCode.
But try it out on the $20 a month plan
because
this is an exciting exciting update for the people that haven't had a chance to test it out yet.
Alright. So jumping over to the next topic here that I wanna talk about,
and this is one that
kind of threw me off a bit when I first were getting going, but I've come to really appreciate it.
And
that's really that prompting matters a ton.
So you can actually guide Claude
to I d ideate with you. You can guide Claude to think very hard Claude code, to think very hard about something. I work very hard about it or make a checklist.
And it's just all about how you prompt it. So a few things that really changed it for me, and I'm not lot of you probably know this already,
but I literally will type in ultra think
about this thing,
whatever it is, and implement the following.
You can also do things like architect,
plan,
and
implement
the following.
Things like that make a huge difference
in, like, getting it to do what you want it to do.
And you don't have to use UltraThing because sometimes you may just want something basic to be done. So you just say, you know, do this thing. You can also say, don't write any code. I want to ideate with you.
And this is important because, uh,
what you wanna do in certain cases is think through a plan and kinda figure things out.
I typically use augment code for this, just to be totally honest.
But I have found myself doing this more and more with Cloud Code because I find that that is just it's actually pretty good at it at times.
The other thing that's really interesting is REPL.
And so, basically, what you can do is you can do something like, um,
tell me
tell me about my code base.
And it will create,
like, a read, evaluate print loop. It's what REPL stands for.
And it does a really, really good job answering
kinda context
specific questions.
Try it out, especially if you're using the pro plan.
I was very impressed with its ability
to pick up context of your code base.
And it gets better
if you run the init command and create a cloud dot m d file.
And this is something that you can keep up to date.
But, basically, what claud will do is go through your code base and build it so sort of, like, information,
kinda like a map of your code base that it can then use. What's also interesting about this is it will search for other,
uh, AI tools
and see how you prompted those. So it'll say, like, do you have GitHub Copilot instructor? Because I found mine when I was doing it, and it kinda built, uh, used some of that stuff. It searches for, like, cursor rules and so on. So it knows about the other files that it's looking for there when it's when it's kinda building out that rule set.
So I would I would learn to talk to it in the way that works for you.
I I started out thinking that I needed to be, like, very specific.
So I was like, you know, you basically you can use at to go, like, chat.ts.vu,
and then you can tab into
to kinda complete that
so that it picks the reference to that file. And I would say change this specific thing.
And
it's really, really good when you do this.
And if you got a high enough level or a strong enough level understanding of your code base,
this is the quickest way to get things done in your code.
But you can also be very vague.
And this is the thing that surprised me the most because
its REPL loop does
pretty dang good at figuring out what it needs to do. So I can say something like,
you know, in my orchestrator mode,
I want to add a new tool,
blah blah blah. So,
basically, I'm not giving it files. I'm just saying go do it. And,
know, 80% of the time,
it'll find what it needs to and
make some good, uh, good changes there.
The other thing that I would say is it's important, uh, on the prompting side
to not be afraid to, uh, to kind of start over.
Because sometimes you prompt it, and you realize when you reread it that you were too vague.
Or, actually, it answered the question, but you had meant something different. Because a lot of times I get busy, and I'm like, oh, no. No. No. No.
And
I looked back over there. I'm like, oh god. I woulda had no idea. I'm surprised it actually got as far as it did. So don't be afraid to start over and just revert and do it again.
Uh, because a lot of times, I find that people feel like they have to keep grinding in the same direction, but don't do that. Like, get rid of it and and start over. So now what I wanna do is I wanna go through some tips that I've learned
that have actually really helped me a lot with, uh, using Cloud Code.
The first thing is if I want to do something like I kick off a task let me do that right now. So in this one, I'm actually going to ask it to ultra think through refactoring a file.
I can also type in stuff while it's syncing. Please make sure
all functionality
remains intact.
Also, make sure that
you break out components
when possible.
So you can send it messages while it's thinking. This is something that's very it's kind of an awesome feature that I didn't know about
until a few days after they release it. It's a fairly new feature.
But it's worthwhile knowing that this exists because
it will allow you to think about,
oh, I should have told it this. And now you can actually send it, and it'll do a good job
kind of pushing that in. The other thing that I would say is don't immediately just go to yes and don't ask again in the session.
Make sure
you're comfortable with the direction that it's going
before you kick that off. Um, and then use this no and tell Claude what to do differently a lot.
This has saved me so many times when it is unclear or going away that I don't like. I'll say something like, no. I'd rather you focus on a different part. You know, this this is all too vague right now, but you get what I'm saying here. It's like you can actually redirect it if it's going going awry there.
Then I just wanna be like, alright. I'm gonna clear this. Let's get get rid of that. We're starting over with a new context here.
So you can also use at to get a list of files. So I can see if you hit at here and I start typing chat.ts.view,
I can hit enter, then the path will be
be filled in there. So in this in this query here,
I'm telling it in a particular file.
I'm telling it the problem.
In this case, I don't have an idea what the prob like, how to actually fix it, so I'm asking it to give me ideas on how to fix it. And because I've directed it into that file,
it's going to be a lot better at helping track down that problem there. So that's a it's something that highly, highly recommend that, and it's really, really helpful if you know
the area of the code that you wanna work in.
But you don't have to be that specific on it. You can be very
vague, but you should also be kind of specific too if possible. So you can be you can target functions. You can target files.
You use things that are greppable or searchable. It's really good at that, very similar to the way Codex works.
And so in this case here,
uh, it's adding some debugging logs because it doesn't really know it's trying to get some information on it. I think this is fine. I'd probably accept this and kind of continue on there.
But if I if I want to be super vague on it so here, I'm gonna ask it, can you walk me through writing code about how to add a new tool like multi image? But this time, I want it to be search and replace for brief chat.
Now what this is going to do,
I didn't give it a file to start in. I did give it some things that are greppable,
but I wouldn't even have to do that. It usually will do a pretty good job finding it.
And I've actually tested this prompt a few times,
and this one actually will return really, really good results. So if I take this same prompt here,
and I'm going to open up AugmentCode over here on the right,
and you can see some of the stuff that I do in there. I'm gonna put it in chat mode, and I'm just gonna say,
basically the same question.
And we're gonna take a look at kind of what it comes up. So this one at said to create a new search replace tool handler,
which is awesome.
And, yep, that's exactly what it's talking about here. It's a very, very similar
similar response. It's very, very snappy for each.
So for this longest time,
I actually just kind of the first couple weeks I used Cloud Code, I kind of ignored
its ability to pick up context of my code base.
Don't do that. Like, if you're not paying for Augment code,
Cloud Code does a really,
really good job,
uh, getting context of your code base.
And whatever they're doing under the hood here is incredible.
So that that's kind of just some of the tips that I picked up kind of running through this.
Now on the command side,
there's only a few that I think are, like, very important. The omit one we talked about,
I'd recommend trying this.
It's impressive the what it puts together, and the CloudMD file does help, uh, in my experience.
On an existing code base, it does help.
Now
what this will do is this will actually generate a Cloud dot MD file, and I can show you some examples of that here in a minute. I'll actually pull over to to Versus Code and just run this in my one of my repos. I've cleared it out already. I'll show you what that looks like.
Now the other command is clear. This is one that's very important
because there's sometimes you're just done with the
you're done with the context that you're in. So, like, wipe it out and start a new context. Don't keep it going forever.
Don't be like one of the people that keep a chat window going forever
and don't realize that you should just clear your context. So clear it When you're done,
there's also
models. So you can actually switch switch what models are active.
This can be things like Opus or Sonnet four. Sonnet four is what I run on a daily basis. I very rarely switch to Opus because that eats into my limits
very, very highly.
The other thing that they have is they have a compact command.
This is one where
it will it will auto run for you. You don't really need to worry about this a lot of times, so you can just let this kinda do its thing. Right?
If you are running
via the API, there is, like there's a cost command and there's a status command,
and then all the normal ones, like log in and log out.
These are the ones, if you're just getting started, that you should just get comfortable with, specifically,
a net clear, checking your or changing your model,
compacting.
Beyond that, everything else becomes kind of advanced and awesome. Right? Like, things that you can run a cloud code via a deploy pipeline.
So you can or you could have it set up so that it runs
on where with no input. So just auto runs for you. So there's a lot of, like, really advanced stuff you can do, which I've been playing around with. And I think it's important just to keep that all that in mind.
Now orchestrating tasks, this is something that I actually really
am excited about.
Because we have a CLI tool,
if you think about it, it becomes very easy to specifically
take and send out bite sized jobs.
And so in root code, what I actually did is I created a, uh,
a clog code mode
that literally would break out tasks,
and it would send CLI command
to clog.
And
this is great, and it works great some of the time. I honestly found it more kind of a pain than anything trying to it go between root code and, uh, cloud code.
But there are tools starting starting to pop up where you can
manage multiple cloud code instances.
One of the problems I run into a lot of times, a lot of them don't support WSL very well.
So, again, when I have to go over to Linux to try them out. But I do locally the way I do a lot of orchestrating of tasks. I do that with Git Worktrees.
And git work trees is something that's actually really, really, really powerful.
Or, I mean, simply, you can actually just, uh, run multiple instances.
I've never ran into an issue having two or three instances running at a time, and I typically run them in the terminal window of my Versus Code. So it's just all right there. I know some people might prefer to run that outside of Versus Code, but I I'm traditional IDE guy. I like it being a Versus Code. It just it's so nice having it integrated in there very well.
On the Git Worktree side,
what it typically does is you can actually
set up sort of, like, feature branches
in sort of this tree structure. So there's these things like Git Worktree
add.
Right? So you can do git work tree. You can list them. You can do git work tree. I think it's remove.
There's some other commands too. I think prune is one. I'd have to go through and and look at all of them. So what you do here is you go git work tree add.
Here's your path to where you wanna add it to have the the repository
sort of synced to,
and then this would actually be your branch.
And now you can just c d into that path
and run plot.
And I can run that and have multiple instances working on different feature branches
very, very easily,
and then just switch over to the run them. I still run into the same issues that I have locally with my other type of multi
agent systems, which is I have a I have a server that needs to be booted up, and this is kind of, uh,
probably
kind of whining more than anything. But, basically, I have to stop and start the server when I switch between those instances. So it's not the most ideal thing,
uh, where, ideally,
I have that could be a little bit quicker
for me to actually be able go in and test it. It's again, it's just me kinda whining about it more than anything. So on the impression side, I just wanna say it's very positive.
I have very few negative things that happen.
What I will say on the negative side
is there are times
that you end up with situations
where, um,
spacing
or merging
or
weird states you get into it
where you can't
get clogged code to fix it, you're better off just nuking it or going into manually fixing it. Trust me, I've spent enough time with clogged code now to basically be able to pick up instantly when it's in a position where it's not gonna get out of it. Sometimes
it's
it's just simple with, I know this just gets on the but tabs versus spaces,
it will,
uh, get into a state where it just can't merge things because it's trying to do one or the other, and it just is really weird. It's very rare that these things happen.
But, again, it's just you'll you'll pick it up as you use it that if as long as you're committing and you're keeping the progress of things you're working on well enough, you're not gonna feel bad reverting whatever change it's got
or go in and help it sometimes.
Uh, but on the positive side, it is just fun.
Like, I'm not kidding you about how much fun it is to use.
I
it's
everything about it just exudes
fun.
And
I know it's it's coding, and a lot of people would be like, uh, why is that fun? But it really is. I
I feel like it's
so good at what it does, and there's so much
nuance to how you kind of guide it
that
you feel like you have control of it.
Whereas some of the other AI agents,
you have some control,
but not to the point that clog code is. I don't need to change modes.
I basically just guide it based on how I prompt it to behave
from this ultra hardcore,
like, really deep thinker, task list creator,
all the way down to, I just wanna talk to you about an idea that I've got.
And there's all the variance between there that just makes you feel like you have control over this agent
unlike other agents.
And
you may find that you can just reword a problem
that
other agents have trouble with, and you word it in such a way with ClawCode, and it'll freaking nail it.
The other thing that I wanna say from the impression side is
that it's fast. Like, it it is
never it never feels to me like it's a slog.
So a lot of times, you know, with some of the other agents, especially GitHub Copilot,
one of my big complaints about that is how slow it is. It it literally takes, like, triple the time some of these other agents.
But Cloud Code is fast.
You can make it faster, and you can make it slower by how you prompt it, which is also what I love about it, which goes back to sort of the control that you have over it. Um, until you use it, you really would have a hard time understanding what I'm saying about that. But it is it is a real thing that I feel. I'm jumping over into Versus Code because I wanted to show you what this looks like in practice here.
So the first thing that I would do is you can see here that I've been working with ClawCode
quite a bit today.
Now I have nuked my
particular
claud dot m d file.
And as you can see here, there's actually an update ready.
So I'm gonna go ahead and restart claud. That was weird. I actually got a weird error here at first, which I've never got before, so that was kinda interesting.
Regardless,
I am
in Clog. The first thing that you see when you come in
is
this what's new.
It's such a such a nice little touch. I know it's not much,
um,
but you've got this Clog code can now be used with Clog Pro subscriptions.
You also have this upgrade,
which
is pretty dang sweet. That is a cool feature that they've added,
uh, where before I logged out, I had to log back in to kinda link my max plan.
And I can tell you right now the to do list stuff has actually been
handled very well after compaction. I their compaction feature is state of the art. Like, it's incredible.
So now let's just run a net here, and I'll kinda show you what this looks like and kinda talk through what it's doing. Now this actually may take a while, and I may have to speed up
some of this.
It's looking at the entire code base structure. It's reading some lines of code. You could see sort of the style that it adds. Like,
we've got this actualizing.
It keeps track of the number of tokens.
There it's really informative that things are happening. This usually takes a few minutes. So what I'm gonna do here is I'm just going to
periodically talk about what's happening, but mostly skip over a lot of this. So now we're at the point where it has done the analysis of my code base,
and I'm gonna go ahead and say, yes. You can create that file. You can kinda see what it asks you. The second option is yes, and don't ask me again during this session.
That's also a really nice thing because
there are some commands when I'm working with it that I always want to approve.
There are other commands that I never want to auto run, so I I like having that that control there.
And you can see here that it did 15 tool users, 61,300
tokens,
one minute thirty six seconds, and it completed the claw dot m d file. And just to show you what that looks like here
and how it actually comes together,
uh, this is what it does. It kinda builds its own guide
that it uses to help better, uh, kind of understand
the
structure of my code base. It even picked up my
old folder that I'm trying to phase out of that. It's kinda migrated up into a new version of, uh, Vue.
It's got all the technology that it's used. We've got all the domain models. Does a really good job with local development. Like, all of this is 100%
correct.
All of this is correct.
So it's it's really
it's really useful. And I found that this kind just having this kinda does speed up the development efforts a bit.
In particular, for me, we care a lot about our design
stuff. So having this in here is actually really nice as well because
it doesn't need to go look in other code to try to figure out that design.
You can see our integrations that it's using, so on. Right? So now I am in the RU code repos. This a public code base that you can pull down from GitHub.
And I basically asked it to diagram out
how the Orchestrator
subtask
version system works.
So you can see here that it actually generates some mermaid diagram sequences.
We need to load those into mermaid renderer to kinda see how that actually works.
But let's not focus on that right now. Let me focus on the flow that this actually went through here.
So the first thing that I ended up doing here
is I basically asked it to tell me about this code base. So this is one of those generic
queries that I was talking about.
It read the read me. It read the package dot JSON,
and it got enough information from that
to give me a definition of what the code base is. It even picked up the the main components on it. This was relatively fast. Let me see if it actually tells me the time there. I don't think it does when we're this part in. Now,
basically, what I I did is I ran a net on it. So let me show you what the, uh, cloud dot m d file looks like here.
And you could see that it actually did 26 tool users, 90.6 k token, and ran for two and a half minutes to generate that.
And I knew a good amount about the root code code base,
enough to say that the majority of this I can confirm is correct, but I I'm not as familiar with every part of it. So I don't have the same ability that I do with my own code base to be able to say, yeah, that's 100%
all correct.
But it did generate a 149 lines of information
here based on, you know, 90,000 tokens that it ran through.
And you can kinda see some of the summarization there.
Then I basically ask it about diagramming it out. I actually told it to ultra think through this,
and you can see
very particular. Like, you can feel the difference that it needs to go through. Like, look. It triggers this thinking
portion in here.
So you can start seeing thinking where if you go up through these, because I didn't tell it to ultrathink,
you're not actually getting the thinking as part of the output here.
So you could see that just carry through through all of this. Now it does slow down
the process, but sometimes you really do want it to take its time
and generate,
you know, a more thoughtful response.
Four minutes and, uh, nine seconds. So there we go. 32 tool uses,
88,000 tokens, four minutes and nine seconds. So now that I've had that got sort of this high level understanding of the Orchestrator subtask system,
what I would typically do now
is this is a this is a feature I've been wanting in RootCode for a while,
where I want to be able to represent in Root in RootCode,
basically,
the orchestrator
and all the subtask,
how much each of those you use, how much do they cost, how many tokens they use, and be able to visualize that and ideally click through them.
I don't actually have an idea for I haven't set that. I figured out the design on that. But, basically, I could go and kick this off now and say, hey. Now that you have that, go figure out a way to do that
and get some ideas on it. Most likely, it's not gonna be something that, um, we're going to to actually be able to keep,
but that's just an idea of kinda how you can work through this. So here, you can see that it actually created its own to do list,
and it's gonna work through it one by one. So if you watch my previous video where what I talked about a lot here so let me move my video over a little bit,
is basically the rankings of each agent.
And Cloud four does really good. Cloud four Sonnet, very specifically Sonnet,
does really good in Cloud Code.
And it should because it is their tool that they're building. They understand the inner working of it very well.
And it kind of goes to
say, like, my personal ranking is this, and I don't see this changing
drastically over the next month. It has
historically changed a lot. Like, one time,
I was using cursor 100% of the time,
and then I was using, uh, I used Klein for quite a while,
and then I used Augment for quite a while. And I still use Augment now. I think they're phenomenal for certain things.
And that it just
you know, you kind of have felt so much sort of
turbulence in this space because people are leapfrogging each other.
But I think Clog Code is just this really sweet spot for me. Just it's my workhorse. So I think Cloudcode is just a sweet spot for me. I'm gonna be paying for the foreseeable future, the $100 a month until that ends up being, like I if if they start nerfing it,
I'm gonna, uh, probably upgrade to the $200 a month plan.
But I I really do need to try to get my spin down. So
my current stack that I'm gonna be running is going to be
$30 a month for AugmentCode because I'm on the grandfathered
plan.
I'm go I currently have $200 a month for
OpenAI
because of codec.
There's something really special about codec being able to be on a bike ride, get something popped into your head, pull over, get kick something off, bring it back, and work on it in Clog code. Now I think there is probably a way that I could probably downgrade this now that they've given you access on, I think, the pro plan.
So I'm gonna look into that because I don't know what the limits are on that. But if the limits are where I can run five, six tasks a day on Pro Plan, there's no reason for me to be on the $200 a month plan there.
And then the other thing would be, like, API cost.
Now my API costs are kind of crazy because eval, typically, they've started to creep up in in pricing.
So, you know, I'll spend, you know, $200
at eval run easy,
and that's me trying to use models that are built into these systems as well. So this can actually run 200,000 200 to $1,000 a month just on trying to run, um,
evals and testing all the different models and stuff. So this is for clogged code.
I'm going to be having my $30 augment code. I'm gonna be keeping codecs for foreseeable future.
And then this is going to be a combination of root code
and any other API costs that I have. Of course, there's just going to be miscellaneous costs with with testing other things.
So one thing that I'll just note in here is Google
has kind of fallen way off.
There is always a chance. There's some upcoming rumors about them launching something
that may bring me back into using
Gemini
or, uh, Google models again.
But it's going to it's going to be need to be, like, something
pretty massively good because Cloud Code right now
is in an incredible spot.
Now I think that's gonna about wrap it up. There's so much I could talk about about ClockCode. Is there anything you want me to go deeper into on ClockCode? Let me know. I've been getting so much feedback on all the stuff that I've been doing. Trying my best to take that in and just continue doing better and better.
Anyway,
I appreciate all of you. Let me know your thoughts below. If you've had a chance to try Clogcode, if you're paying for the 100 or $200 a month plan,
if you hit limits because I've never hit a limit on the $200 a month plan, but I've heard people hitting it on the $100 a month plan. So I'm curious what is gonna happen as I switch to that.
Anyway, till next time, everyone. Have a wonderful, wonderful day. Peace out.