← All Posts

A 65-Line File That Fixes Claude Code. Here's What It Actually Tells Us About AI.

Someone turned Andrej Karpathy's three biggest complaints about AI coding agents into a 65-line text file. Developers using it report Claude Code accuracy jumping from 65% to 94%.

That number is worth sitting with. Not because of what the file does. Because of what the gap reveals.

Who is Karpathy and why does this matter

Andrej Karpathy is one of the most credible voices in AI. Founding member of OpenAI. Former head of AI at Tesla. Founded Eureka Labs. Joined Anthropic in May 2026. When he posts about what AI is getting wrong, the industry listens.

His complaints about AI coding agents are specific. Not vague frustrations. Three precise observations about where the behavior breaks down.

• Silent assumptions instead of asking clarifying questions
• Overcomplication: writing 200 lines when 20 would do
• Touching code you never asked it to touch

Someone took those three complaints and built a CLAUDE.md file from them. Drop it in your project folder and Claude Code reads it automatically at the start of every session. Thirty seconds to set up. The accuracy jump that follows is significant.

You can find the file here: github.com/multica-ai/andrej-karpathy-skills

The three complaints, unpacked

One: AI guesses when it should ask. When a coding agent isn't sure what you mean, it has two choices: ask, or assume. Almost every agent assumes by default. Guessing produces output. Asking feels like friction. The result is code that compiles but solves a problem you didn't have. The Karpathy file flips this: before writing anything, Claude has to either confirm its understanding in one sentence or surface the specific ambiguity and ask.

Two: complexity is the default, not simplicity. Ask Claude to add a button and you often get back a button, a wrapper component, a config file, and a small refactor of the parent. Five files. One feature. Nobody asked for the abstraction. The fix: minimum viable code, no speculative flexibility, no preemptive generalization. Three similar lines stay as three similar lines until there's evidence they'll become five.

Three: it touches things you didn't ask it to touch. A one-line fix that comes back as a 200-line diff because the agent "cleaned up" while it was in there. The rule: surgical changes only. Edit what was requested. Leave everything else exactly as it was. If the surrounding code is bad, say so. Don't silently fix it.

There's a fourth rule worth noting: every task needs a verifiable success criterion up front. Did the test pass? Did the bug disappear? You can't be "done" until you can prove it.

The real insight here has nothing to do with code

Here's what actually caught my attention about this.

The file isn't magic. It's just a set of clear instructions in a place Claude reads by default. What makes it work is this: Claude Code's default behavior is much sloppier than its actual capability. The gap between what the model can do and what it does without direction is enormous. A plain text file closes most of that gap.

The model wasn't failing because it wasn't capable enough. It was failing because nobody told it what they actually expected.

This maps directly onto something I keep coming back to in my own work with AI. The bottleneck is almost never the model. It's the absence of direction. You get lazy AI output when you treat AI as a vending machine instead of as something that needs to be briefed, steered, and held to a standard.

I actually use a CLAUDE.md myself. Not for code — for my second brain. A personal knowledge base I've been building with Claude as the steward. The file tells Claude how to process new material, what categories exist, how to write in third person, how to flag contradictions. Without it, every session would start from scratch. With it, Claude knows exactly what it's maintaining and why.

The principle is the same whether you're building software or a personal wiki: the quality of the output is directly proportional to the quality of the context you provide.

How to set it up in 30 seconds

This is the practical part. Even if you're not a developer, it's worth understanding how simple this is.

1. Open the GitHub repo and copy the contents of the CLAUDE.md file.

2. Paste it into a new file called CLAUDE.md in the root folder of your project. Same level as your package.json or .git folder.

3. Save. Done. Claude Code reads it automatically at the start of every session.

If you already have a CLAUDE.md in your project, just append the Karpathy rules to the bottom.

What this means beyond the file

The 65% to 94% accuracy jump is interesting. But what I find more interesting is what it says about how most people are using AI right now.

Most people are using AI at default settings. Wondering why the output is inconsistent. Blaming the model. Accepting the slop.

The people getting genuinely good results are the ones who understand that AI needs direction. Not just a prompt. Direction: a clear brief, defined constraints, stated expectations, and a standard to be held to. The same things you'd give a talented but uninitiated person on their first week.

AI doesn't under-deliver because it's incapable. It under-delivers because nobody told it what good looks like for this project, this context, this person.

AI does not remove the need for taste. It exposes the lack of it.

A 65-line file can close a 29-point accuracy gap. That should tell us something about where the real leverage is. Not in waiting for a smarter model. In getting better at setting the standard for the one you already have.

Are you using a CLAUDE.md or any kind of persistent instruction file in your AI workflow? I'm curious what's in it.