Andrej Karpathy's LLM Coding Rules Are Now a Claude Code Plugin (70k Stars)

The Week a CLAUDE.md File Hit 70k Stars

At 70,300 stars and growing, forrestchang/andrej-karpathy-skills is the most-starred repository on GitHub trending this week, gaining 44,394 stars in seven days. That number is striking for a project containing a single instruction file and a few supporting docs. No flashy framework. No new model. Just four precisely-worded principles that tell Claude exactly what it keeps getting wrong.

The repo distills a specific observation from Andrej Karpathy - the former Tesla and OpenAI researcher whose commentary on LLM behavior carries weight in the AI developer community. His core critique: models make unfounded assumptions, over-engineer solutions, and silently modify code they do not fully understand. This repo attempts to encode the fix in a format Claude Code can act on directly.

What It Does

The heart of the project is a CLAUDE.md file built around four behavioral guidelines.

Think Before Coding - Claude is instructed to surface assumptions explicitly before writing a line of code. If a request is ambiguous, the model asks for clarification rather than guessing. A request like "add a user export feature" gets met with questions about scope (all users or filtered?), format, fields, and expected volume before any implementation begins.

Simplicity First - The guideline is direct: "Minimum code that solves the problem. Nothing speculative." This targets a well-known failure mode where models add caching layers, abstract base classes, and validation logic that nobody asked for. If the implementation grows unreasonably long, the instruction says to stop and rewrite.

Surgical Changes - When modifying existing code, Claude should touch only what the task requires. The rule is explicit about pre-existing dead code: do not remove it unless your own changes orphaned it. Match the existing code style and do not refactor adjacent functions as a bonus.

Goal-Driven Execution - Rather than working from vague instructions, Claude transforms each request into verifiable success criteria with clear checkpoints. "Review and improve this function" becomes "write a test reproducing the bug, implement the fix, verify the test passes, check for regressions." Each step can be independently verified.

The project also ships a CURSOR.md and a .cursor/rules/karpathy-guidelines.mdc for Cursor users, plus an EXAMPLES.md demonstrating how each principle changes behavior in concrete coding scenarios. The license is MIT. There are 28 commits on main, 6,400 forks, and 374 watchers as of this writing.

Install or Try It

There are two paths to using these guidelines.

Claude Code Plugin (recommended):

/plugin marketplace add forrestchang/andrej-karpathy-skills
/plugin install andrej-karpathy-skills@karpathy-skills

That adds the guidelines as a plugin that applies across your Claude Code sessions without requiring a project-level file.

Per-project CLAUDE.md:

Download the file and append it to your existing CLAUDE.md:

curl -o karpathy-guidelines.md \
  https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md
cat karpathy-guidelines.md >> CLAUDE.md

This approach works well if you want to combine the guidelines with project-specific context - which is the more common setup for teams working on production codebases.

Cursor users can copy CURSOR.md to their project root, or place .cursor/rules/karpathy-guidelines.mdc in the repo for rules-based activation.

Who Should Use It

If you have spent meaningful time with Claude Code, you have almost certainly hit all four failure modes this file addresses. The assumption problem is especially costly - an incorrect silent assumption at the start of a session can send a long agentic task down the wrong path entirely, and debugging that is expensive in both time and token budget.

The simplicity guideline matters most for developers working on production codebases rather than greenfield projects. When Claude touches existing code, speculative additions create noise in diffs, inflate pull request reviews, and sometimes introduce bugs in code paths that were previously stable.

Surgical changes is the rule most likely to reduce friction when doing partial updates - fixing a single function in a large file, patching a query, or adjusting an API endpoint response shape. Without this constraint, Claude has a tendency to clean up surrounding code as a side effect, which is not always welcome.

Goal-driven execution is the most useful rule for agentic workflows where Claude runs multiple steps without interruption. Success criteria give the model a natural stopping condition and a way to verify its own work before reporting back.

These guidelines are worth the two-command install for any developer using Claude Code regularly. The cost is essentially zero.

Relation to the DevDigest Ecosystem

This project sits squarely in the territory that skills.developersdigest.tech tracks - Claude Code skills, plugins, and behavioral configurations that extend what the tool can do. The karpathy-skills plugin is a lightweight, high-leverage configuration in the same category as community-built plugins for code review, deployment automation, and session context management.

The four principles map well to the workflow patterns covered throughout the DevDigest Claude Code content. The surgical changes principle connects directly to the agent loop patterns discussed in the Claude Code sub-agents and worktrees posts - agentic runs where Claude modifies multiple files in a single session are exactly where uncontrolled edits cause the most trouble.

The CLAUDE.md format itself is central to how many teams manage Claude Code behavior across sessions. These karpathy guidelines are a good complement to project-level context files because they address model-level behavioral patterns rather than project-specific rules. Combining them with automation configured at hooks.developersdigest.tech gives you behavioral tuning at the instruction level and automated guardrails at the execution level - two different layers working together.

For developers building with Claude Code extensively, this is the kind of low-effort, high-signal configuration that compounds over time.

Honest Assessment

The four principles are well-observed and the CLAUDE.md format is effective. The project earned its star count.

The limitations are worth noting. These guidelines work best as a starting point, not a finished solution. Teams with complex projects will likely need to extend them - the simplicity rule in particular requires calibration. Some abstractions are genuinely necessary, and a blanket instruction to avoid them can create friction when Claude correctly identifies a pattern that warrants one.

The "think before coding" principle adds overhead for trivial tasks. The CLAUDE.md itself acknowledges this, noting that judgment should be applied and caution weighted toward complex work.

The Claude Code plugin ecosystem is also still maturing. Plugin installation commands and behavior may shift as the platform evolves. Test the install in a clean session before rolling it out to a team.

None of these limitations undercut the core value. For developers who have been burned by silent assumptions or spec-creep from an agentic run, this file is a practical and immediate fix.

References

• forrestchang/andrej-karpathy-skills: https://github.com/forrestchang/andrej-karpathy-skills
• CLAUDE.md source: https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md
• EXAMPLES.md: https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/EXAMPLES.md
• DevDigest skills directory: https://skills.developersdigest.tech
• DevDigest Claude Code hooks reference: https://hooks.developersdigest.tech