# Andrej Karpathy Skills review: a single 189k-star CLAUDE.md > Source: > Published: 2026-07-16 03:30:38+00:00 andrej-karpathy-skills packages coding practices for AI into a single CLAUDE.md file, distilled from Andrej Karpathy's observations about how models fail when they write code. It reduces to 4 principles: think before coding, simplicity first, surgical changes, and goal-driven execution. It has over 189,000 GitHub stars. Its whole appeal is that it is minimal, one file, the opposite of superpowers, which is a dozen-plus skills with enforcement gates. After reviewing superpowers, I kept scanning Claude Code repos and hit another one with a comparable star count: andrej-karpathy-skills, over 189,000 stars. But when I opened it, it was nearly the opposite of superpowers in every way. Superpowers is a dozen-plus skills with gates and machinery. This one is **a single CLAUDE.md file, under seventy lines.** What can one file do to earn a couple hundred thousand stars? The answer is that it does not try to teach everything. It picks only the failure habits AI repeats when it writes code, and turns them into short rules the model follows. The source of those rules is a post by Andrej Karpathy on X about where models go wrong when they help you code. This post goes in order: what it is and who made it, then the 4 principles it teaches, then how it differs from superpowers and which to pick, and finally whether you should install it and how to use it in your own work. First, provenance, stated plainly: this repo is **not from Andrej Karpathy himself.** It was made by a third party (multica-ai, by Jiayuan Zhang) who took what Karpathy posted on X and arranged it into guidelines. The repo says so directly, calls itself Karpathy-Inspired, and links the source post so you can read it yourself. It uses an MIT license. This matters, because when you see a famous name on a repo you should be able to tell whether it is the person's own work or someone arranging their words. This is the latter, and it says so clearly. The problem Karpathy described is the one many people hit with AI when it helps write code. He wrote, roughly, that models like to make assumptions on your behalf and run with them without checking, do not ask when things are unclear, like to overcomplicate code and bloat abstractions past what the task needs, and sometimes change or remove code they do not fully understand. This repo answers those habits with rules. Beyond the CLAUDE.md file, the repo also ships these rules as a packaged skill under skills/karpathy-guidelines, plus a .cursor port for Cursor users. The whole file boils down to 4 principles, each fixing one of the failures Karpathy named. What is neat is that the 4 connect into one chain. Most trouble starts from an unclarified assumption, then a silent guess, then overcomplicated code, then a drive-by refactor, ending in a vague goal that forces a rewrite. **Each principle cuts one segment of that chain.** Its charm is not completeness but brevity. The whole file reads in a couple of minutes, and every line points at a real thing AI gets wrong, again and again. If you read the [superpowers review](https://productize.life/blog/claude-superpowers/en) first, you will see these two repos solve the same problem, getting good practice into an AI, at completely different scales. They also differ in how they enforce. Superpowers does not trust a rule stated plainly to bind the AI, so it names the excuses the model would use to skip a rule, right in the instruction. karpathy skills lays out principles and trusts the judgment of the model and the human watching over it. **Neither is better in the abstract, they answer different situations.** Work where a human is present throughout, short principles are enough. Work you leave running, you need rails that are hard to step past. It is worth a try, especially if you do not yet have a CLAUDE.md of your own, because it is very light, just a text file with nothing hidden. You can install it several ways: as a plugin, by copying the CLAUDE.md straight into your project, or by appending it to an existing one. The content is open under MIT, so you can read the whole file and take only the parts that fit your work. Even without installing the repo, its most distilled principle is this: **stopping to ask when something is unclear has to count as doing it right, not as failing to finish.** Most AI failures start exactly there, with the model guessing on your behalf and running on. If you write into your own rules file that it should ask first when unclear, you have already cut half the problem. For my part, I took some of these principles and mixed them into the rules file and skills I already use, rather than adopting the whole file, because some of it overlapped with rules I already had. How I wired it into my own stack is a detail I am leaving out of this post, but the principle above you can use right away. If you remember one thing from this post, let it be this: **good practice does not have to arrive as a big kit.** A repo with 189,000 stars is a single file that points at where AI goes wrong and writes a few short rules to guard against it. The size of a tool does not tell you how much it helps. What tells you is whether it names a real problem accurately. *Originally published at productize.life/blog/karpathy-skills. Written from real work, the process, not a pitch.*