Karpathy's Skill Just Fixed Claude Code's Biggest Problem

In this video, we're going to go over

this Andrej Karpathy skills, which got

over 100,000 stars on GitHub. And this

skill is derived from this expose that

Andrej Karpathy has wrote. And if you

don't know what Andrej Karpathy is, he

is previously a director of AI at Tesla

and a founding team at OpenAI. And

currently, this expose has got over 7

million views on X. And essentially,

what this skill does is addressing the

problems that Andrej Karpathy sees on X.

And the first problem we see is the

model here always make the wrong

assumption. So, it doesn't ask

clarification questions. When you give

it a problem, act on it. And the second

problem that he sees is that model here

often times over complicating things.

Things can be wrote in 100 lines, often

wrote in 1,000 lines. And often times,

large language model here making changes

that they're not supposed to without

clear understanding about the full side

effects. So, that's why in this video,

we're going to take a look at what it

is, how does it work, and how does 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 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

going to get over 100 plus video

materials like templates and workflows

that I personally built and sold over

100 plus times. On top of that, you're

also going to get access to our weekly

live calls. And just to give you an

idea, this week we're actually running a

Claude call masterclass where we're

going to dive into how to improve Claude

call's accuracy, and we're going to use

it to building applications. Plus,

you're also going to get full community

supports where you're going to get a

chance to ask questions and get direct

answers back. So, if you're ready to

level up, make sure you jump right in,

and I'll see you in a community. All

right. So, to get started, let's take a

look at what this skill is trying to

offer. So, right here you can see this

skill here offers four principles that

we can use in our project, which will

basically wrote inside of our Claude MD

file. So, first principle here you can

see is think before coding. Large

language model here, like I said, makes

wrong assumptions, doesn't clarify

things. And by having this principle,

it's going to force AI here to have to

think before it's going to 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 1,000 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, then 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 is actually

what this principle does. And the last

one that we have is goal-driven

executions. We need to have a clear goal

on exactly how large language models

here 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 result. And that's

the four principles that the skill is

trying to introduce, and they all

compacted down into a single Claude MD

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 Claude

plugins. Simply, we're just going to add

the skill in our marketplace and install

it. And the second option that we have

is let's say if you want to install this

not globally, but in a project level,

simply you can just do with this curl

command here and add this onto your new

project. But if you have an existing

project, you can simply just going to

run this command right here, and simply

it's going to write this rule onto your

Claude MD file onto your existing

project. Now, for my case here, I do

have an existing project called

bookzero.ai, where I help businesses

here to manage receipts and transactions

all using AI. And what I want to do here

is I want to 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 going to copy this

command. It's going to install this on

existing project. So, here I'm just

going to come over to a project

terminal, open a new terminal, and just

going to paste that command here. And

what this essentially this command does

is going to modify my Claude MD file by

simply adding those four rules onto

there. So, in this case, I'm going to

click click on enter, and you can see

that it's going to modify my cloud MD

file. So, now if I were to open the Git

diff, and here you can see this is the

changes that has applied. And for most

of you guys, you probably already have

your cloud MD file or 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

cloud code to basically try to modify

your cloud MD file. Once you paste that,

once you paste those four principles to

see if there's any conflictions,

any conflicts, anything that's not

following what you have in your cloud MD

file. Like try to merge the conflicts

that you have. And you can see here that

this is what it recommends. After it

pasted from the original car party

skills repository, here's some problem

that I found. For example, we have the

duplicate H1 tag for the cloud MD file

because the cloud MD 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

cloud MD file here doesn't really need

that. It needs the instruction, a clear

instruction on exactly what needs to do.

And we has also have removed some

redundant stuff that's not really

relevant to our cloud MD file. And you

can see cloud code 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 cloud MD 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

going to be an H2 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. Okay? So, you can see

that's exactly how this works. All

right. So, now you know exactly how to

install it, let's take a look at the

clear difference between how they're

different compared to all the skills

that we have mentioned on this channel,

like G stack, superpowers, GSD, all

those spectrum development frameworks

that we have introduced. And a clear

difference is this. GSD, superpower, G

stack, they are all skills. They're all

skills that are being triggered whenever

we trigger them, right? But Claude MD

file is different is that we enforce

those rules inside of a Claude MD file.

I kind of like personality embedded into

the model'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 it's going to follow

these four constraints every time we do

something. When it asks to do I 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 Claude MD 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

G stack, superpower, and GSD. 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 G

stack because none of them has mentioned

anything about like adding extra stuff

or staying your lane 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

Claude MD file here fix that gap by

mentioning these things, right? And we

also have something that's similar to

what we have with superpower and G stack

is rule number one and rule number four,

which is think before coding and goal

driven, right? That's exactly what

spectrum development does is creating

the plan before doing executions. And

what superpower and G stack does a

different is not just bunch of text sets

inside of a Claude MD file is a

framework that we have to first write

our spec, from spec create a to-do list,

and from to-do list creating a action,

right? That's exactly what superpower

and G stack does is creating a framework

that large language model here follow,

but it doesn't build 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 a couple

empty files not going to cut it. We're

going to 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 going to have them to trigger the

superpower system debugging skill. If

it's a multi-step, like three files,

we're just going to directly having them

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 simplify skill

and try to simplify everything. All

right, so pretty much that's it for this

video and All right, so you can see

that's pretty much it for this video.

And if you do find my this video, please

make sure to like this video, consider

subscribe for more content like this.

But with that being said, I'll see you

in this video. And honestly, don't even

stop there. You can also include in G

stock, like the auto plan skill, where

you can you have different rules 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 a bug fix. Okay,

well, let's trigger the test driven

developments here. If it's like

executing a written plan, well, let's do

the executing plan, 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 Claude MD file and

Claude knows exactly what skill it's

going to trigger based on your

preference. Okay, so, pretty much that's

it for this video and honestly, I don't

want to have my Claude MD file here to

be too long, so, I just wanted to keep

it short. Just keep some skills that I

really like inside of a Claude MD file.

All right, so, you can see that's

exactly the end of our skills. And of

course, if you're interested in learning

more about spectrum development models,

be sure to check out the playlist here

inside of the description below, where I

show you all the spectrum development

models that I talk about on this channel

on how you can be able to make your

large language model here to be highly

accurate when performing task on your

project, right? So, if you're interested

for that, make sure to check it out in

the link in the description below. With

that being said, if you do feel my this

video, please make sure to like this

video, consider to subscribe for more

content like this. With that being said,

I'll see you in the next video.