In this video, we're gonna go over this Andrew Kaparvi skills, which gone over a 100,000 stars on GitHub, and this skill is derived from this x post that Andrew Kaparvi has wrote. And if you don't know what Andrew Kaparvi is, he is previously a director of AI at Tesla and a founding team at OpenAI.
And currently, this X post has gone over 7,000,000 views on X. And essentially, what this skill does is addressing the problems that Angi Kaparvi sees on X. And the first problem we see is the model here always make the wrong assumption. So it doesn't ask clarification question. When you give it a prompt, it just act on it. And the second problem they see is that a model here oftentimes overcomplicating
things. Things can be run-in 100 lines, often rows in a thousand lines. And oftentimes, large language model here making changes that they're not supposed to without a clear understanding about the full side effects. So that's why in this video, we're gonna take a look at what it is, how does it work, and how is it different compared to any other skills that we have used in the past. So with that being said, if you're interested, let's get into the video. Now before we continue, I recently launched our school community where I help you to master AI agents, automations, and so much more. And that's all coming from someone who used to work as a senior AI software engineer at companies like Amazon and Microsoft.
And in this community, you're gonna get over a 100 plus video materials like templates and workflows that I personally built and sold over a 100 plus times. On top of that, you're also gonna get access to our weekly live calls. And just to give you an idea, this week, we're actually running a Clawcode masterclass where we're gonna dive into how to improve Clawcode's accuracy when we're gonna use it to build the applications.
Plus, you're also gonna get full community supports where you're get a chance to ask questions and get direct answers back. So if you're ready to level up, make sure to jump right in, and I'll see you in a community. Alright. So to get started, let's take a look at what this skill is trying to offer. So right here, can see this skill here offers four principles that we can use in our project, which will basically roll inside of our CloudMD file. So first principle here you can see is think before coding. Largely new model here, like I said, makes wrong assumptions, doesn't clarify things, and by having this principle, it's gonna force AI here to have to think before it's gonna do the execution.
And the second here is simplicity. Things that can be wrote in 100 lines of code never should be wrote like 500 or a thousand lines of code. Right? Never should be complicating things. And the success criteria here is that if a senior engineer says that this is over complicated, that we should definitely simplify. And that's exactly what this principle is trying to solve. And the third one here is surgical changes.
So let's say we're making changes. Large language models should never touch code that are not related to the instruction that we provide, and that's essentially what this principle does. And the last one that we have is goal driven execution. We need to have a clear goal on exactly how large an extra model can perform before it's going to do the executions.
And it's similar to the first one, but we need to have a clear success criteria for the expected behavior on the end results. And that's the four principles that the skill is trying to introduce, and they all compacted down into a single CloudMV file that we can add into a project to make sure that large language model here never hallucinates when writing code. Now to put this into practice, here you can see it tells exactly how to install this. First of all, what we can do here is that we can install this in Claw plugins. Simply, we're just gonna add the skill in our marketplace and install it. And the second option that we have is, let's say, you want to install this not globally, but in a project level, simply you can just do this curl command here and add this onto your new project. But if you have an existing project, you can simply just gonna run this command right here, and simply it's gonna write this rule onto your CloudWeb file onto your existing project. Now for my case here, I do have an existing project called BookZero dot a I, where I help business here to manage receipts and transactions all using AI. What And I wanna do here is I wanna install this onto this project and see how does it work. Now in order to install this, all I had to do here is just gonna copy this command. It's gonna install this on existing projects.
So here, I'm just gonna come over to a project terminal, open a new terminal, and just gonna paste that command here. And what this essentially, this command does is going to modify my CloudMD file by simply adding those four rows onto there. So in this case, I'm gonna click click on enter, and you can see that it's going to modify my CloudMD file. So now if I would open the git diff, and here you can see this is the change that has applied. And for most of you guys, you probably already have your CloudMD file with your existing project. And by installing it, it might have some contradiction or conflict with your existing rules. So what I highly recommend you to do is basically tell Cloudcode
to basically try to modify your ClawdMD file once you paste that, once you paste those four principal to see if there's any contradictions,
any conflicts,
anything that's not following what you have in your ClawdMD file. Like, try to merge the conflicts that you have. And you can see here that this is what it recommends. After it pastes it from the original Cardpathic Skills repository,
here's some problem that I found. For example, we have the duplicate h one tag for the CloudMD file because the CloudMD file already has that. And here you can see there's some meta framing here that really tells a human reader what a doc does, but the CloudMD file here doesn't really need that. It needs the instruction, a clear instruction on exactly what it needs to do. Now we also have removed some redundant stuff that's not really relevant to our CloudMD file, and you can see Cloggo has also removed that and make it more concise.
So again, same rule, less to read, so that we can be able to make our CloudMD file here more shorter. So now you can see if I were to close this, this is exactly what it has modified. Right? So you can see we have our behavior guardrails,
that's gonna be an h two tag, and now we have our think before coding and simplicity first,
as well as the surgical changes and the goal driven executions.
So you can see that all the four principles are still here, and there's no conflicts between what we have above versus what we have here. K? So you can see that's exactly how this works. Alright. So now you know exactly how to install it. Let's take a look at the clear difference between how is it different compared to all the skills that we have mentioned on this channel, like Gstack, Supa Powers, GSD, all those frameworks
that we have introduced.
And a clear difference is this. GSD, Suhowers,
GSDTACK, they are all skills. They're all skills that are being triggered whenever we trigger them. Right? But Clawd. Md file is different. It's that we enforce those rules instead of our Claude. D file, kinda like personality embedded into the bottle's brain. That every time when it do something, we don't have to mention it. It knows that because it's embedded into its personality,
embedded into its soul that is gonna follow these four constraints every time we do something. When it asks to do do anything, like maybe helping us to writing a blog post or helping us to generate images or helping us to writing code, it's going to embed that. It's going to do this exactly like we mentioned in our CloudMD file. So that's the clear difference between the two. Now other than their types,
let's talk about the functionalities.
Right? Because these four principles actually cover a lot of those things that we have mentioned previously on this channel for those skills that we have mentioned, like GSTAC, superpower,
and GST. How is it different, right, in terms of functionality?
And you can see here that I asked AI on exactly the difference. And you can see here that rule number two and rule number three here has pointed out by AI that is uniquely different compared to superpower and GSTAC because none of them has mentioned anything about, like, adding extra stuff or staying your length or they don't really mention about these things as, like, the constraints.
They both teach how to work carefully, but they don't know how much, like, to do. Right? Your guardrails here, which is, you know, our CloudMD file here, fix that gap by mentioning these things. Right? And we also have something that's similar to what we have with superpower g stack is rule number one and rule number four, which is think people coding and goal driven. Right? That's exactly what spectrum development does. It's creating the plan before doing executions.
And what superpower and g stack does different is not just bunch of text sets inside of a CloudMD file, it's a framework that we have to first write our spec. From spec created a to do list, and from to do list creating a action. Right? That's exactly what superpower and g stack does. It's creating a framework that large numbers model here follow, but it doesn't built into the brain. But most of them are very similar. Right? The same rule, the same concept is very similar between the two. But that's why my recommendation,
my workflow is combining the all of them. Right? Combining the two. Not just showing them the constraints, but also giving them the path on exactly which skill to trigger. For example, each of the principles that Karpathy has mentioned, like think before coding,
like don't assume, like, service the the trade off before writing code, we will give them the path on exactly what skill to trigger. For example, just couple of MD files is not gonna cut it. We're gonna let them to basically direct them to trigger the superpower skills. Like, for example, the superpower brainstorming skill for adding new features. Or if it's like bug, error, or test, like, test error, like test failure, we're gonna have them trigger the superpower system debugging skill. If it's a multi step, like three files,
we're just gonna directly having to trigger the writing plan skill or the GSD planning phase skill. Basically, try to
execute it really fast, creating a to do list and try to execute it. Right? And for simplicity first, there's actually bunch of skills for simplicity, like making code more simplified, like minimize the code that solves the problem, nothing speculative.
So you can see before committing, polish. So whenever we try to commit things, okay, well, let's trigger the Symbolize skill and try to Symbolize everything. Alright. So pretty much that's it for this video and alright. So you can see that's pretty much it for this video. And if you do find this video, please make sure to like this video, consider subscribing for more content like this. But with that being said, I will see you in the next video. And honestly, don't even stop there. You can also include in G Stack, like the auto plan skill, where you can do have different roles here to introduce for think before coding. The possibility here is is endless. Right? You can actually add a lot of things in here. For example, there's also surgical changes. You can also add, like, using different work trees for, you know, breaking it into different environments,
and there's also goal
driven executions. Right? Making sure that we're setting a clear goal, right, for the success criteria.
So implement a feature or bug fix. Okay. Well, let's trigger the test driven developments here. If it's like executing a a written plan, well, let's do the executing plans. Right? So there's actually a lot of skills that does that. For example, if we want to do a security review, there's also security review. There's also data audits. There's also QA. So we'll give them path to the skills that we have and making sure that not only following the constraints, but also calling the right skills to act on it. Right? So you can see the possibility here is endless, and you can just pick the skill that you want and just add it into your cloud.me file, and Cloud knows exactly what skill is gonna trigger based on your preference. Okay. So pretty much that's it for this video. And, honestly, I don't want to have my CloudMD file here to be too long, so I just wanted to keep it short. Just keep some skills that I really like inside of our CloudMD file. Alright. So you can see that's exactly the engine capacity skills. And, of course, if you're interested in learning more about spectrum data frameworks, be sure to check out the playlist here inside of the description below where I show you all the spectrum data frameworks that I've talked about on this channel on how you can be able to make your large entry model here to be highly accurate when performing task on your project. Right? So if you're interested for that, uh, make sure to check it out in the link in the description below. But with that being said, if you do feel like this video, please make sure to like this video, Consider subscribing for more content like this. But with that being said, I'll see you in the next video.