A founding member of OpenAI dropped a CLAUDE.md onto GitHub, racked up 44k stars in a week, and pushed the total star count to 100k — even Stack Overflow never got that treatment.

His observation: the biggest problem with AI coding isn’t that it can’t work, it’s that it’s “too eager to improvise.” Ask it to fix a bug, and it refactors three files on the side. Ask it to add a validation, and it builds an entire framework on the spot.

So he laid down four rules for the AI: 1. If you’re not sure, ask — don’t guess. 2. If 50 lines can do the job, never write 200. 3. Only change the code that needs changing. 4. The goal is to pass the tests, not to show off.

One document turned an AI assistant from a disaster into a powerhouse.

https://github.com/forrestchang/andrej-karpathy-skills/tree/main…

multica-ai/andrej-karpathy-skills

Source: https://github.com/multica-ai/andrej-karpathy-skills

Karpathy-Inspired Claude Code Guidelines

Check out my new project Multica (https://github.com/multica-ai/multica) — an open-source platform for running and managing coding agents with reusable skills.

Follow me on X: https://x.com/jiayuan_jy

A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy’s observations (https://x.com/karpathy/status/2015883857489522876) on LLM coding pitfalls.

English | 简体中文

The Problems

From Andrej’s post:

“The models make wrong assumptions on your behalf and just run along with them without checking. They don’t manage their confusion, don’t seek clarifications, don’t surface inconsistencies, don’t present tradeoffs, don’t push back when they should.”

“They really like to overcomplicate code and APIs, bloat abstractions, don’t clean up dead code… implement a bloated construction over 1000 lines when 100 would do.”

“They still sometimes change/remove comments and code they don’t sufficiently understand as side effects, even if orthogonal to the task.”

The Solution

Four principles in one file that directly address these issues:

The Four Principles in Detail

1. Think Before Coding

Don’t assume. Don’t hide confusion. Surface tradeoffs.

LLMs often pick an interpretation silently and run with it. This principle forces explicit reasoning:

• State assumptions explicitly — If uncertain, ask rather than guess
• Present multiple interpretations — Don’t pick silently when ambiguity exists
• Push back when warranted — If a simpler approach exists, say so
• Stop when confused — Name what’s unclear and ask for clarification

2. Simplicity First

Minimum code that solves the problem. Nothing speculative.

Combat the tendency toward overengineering:

• No features beyond what was asked
• No abstractions for single-use code
• No “flexibility” or “configurability” that wasn’t requested
• No error handling for impossible scenarios
• If 200 lines could be 50, rewrite it

The test: Would a senior engineer say this is overcomplicated? If yes, simplify.

3. Surgical Changes

Touch only what you must. Clean up only your own mess.

When editing existing code:

• Don’t “improve” adjacent code, comments, or formatting
• Don’t refactor things that aren’t broken
• Match existing style, even if you’d do it differently
• If you notice unrelated dead code, mention it — don’t delete it

When your changes create orphans:

• Remove imports/variables/functions that YOUR changes made unused
• Don’t remove pre-existing dead code unless asked

The test: Every changed line should trace directly to the user’s request.

4. Goal-Driven Execution

Define success criteria. Loop until verified.

Transform imperative tasks into verifiable goals:

For multi-step tasks, state a brief plan:

``

1. [Step] → verify: [check]
2. [Step] → verify: [check]
3. [Step] → verify: [check] ``

Strong success criteria let the LLM loop independently. Weak criteria (“make it work”) require constant clarification.

Install

Option A: Claude Code Plugin (recommended)

From within Claude Code, first add the marketplace: /plugin marketplace add forrestchang/andrej-karpathy-skills

Then install the plugin: /plugin install andrej-karpathy-skills@karpathy-skills

This installs the guidelines as a Claude Code plugin, making the skill available across all your projects.

Option B: CLAUDE.md (per-project)

New project: bash curl -o CLAUDE.md https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md

Existing project (append): bash echo "" >> CLAUDE.md curl https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md >> CLAUDE.md

Using with Cursor

This repository includes a committed Cursor project rule (.cursor/rules/karpathy-guidelines.mdc) so the same guidelines apply when you open the project in Cursor. See CURSOR.md for setup, using the rule in other projects, and how this relates to Claude Code.

Key Insight

From Andrej:

“LLMs are exceptionally good at looping until they meet specific goals… Don’t tell it what to do, give it success criteria and watch it go.”

The “Goal-Driven Execution” principle captures this: transform imperative instructions into declarative goals with verification loops.

How to Know It’s Working

These guidelines are working if you see:

• Fewer unnecessary changes in diffs — Only requested changes appear
• Fewer rewrites due to overcomplication — Code is simple the first time
• Clarifying questions come before implementation — Not after mistakes
• Clean, minimal PRs — No drive-by refactoring or “improvements”

Customization

These guidelines are designed to be merged with project-specific instructions. Add them to your existing CLAUDE.md or create a new one.

For project-specific rules, add sections like:

``markdown

Project-Specific Guidelines

• Use TypeScript strict mode
• All API endpoints must have tests
• Follow the existing error handling patterns in src/utils/errors.ts ``

Tradeoff Note

These guidelines bias toward caution over speed. For trivial tasks (simple typo fixes, obvious one-liners), use judgment — not every change needs the full rigor.

The goal is reducing costly mistakes on non-trivial work, not slowing down simple tasks.

License

MIT