The andrej-karpathy-skills repo (originally published as forrestchang/andrej-karpathy-skills, now hosted under the multica-ai GitHub organization) turns a January 2026 post by Andrej Karpathy into a single CLAUDE.md file. We checked the repo's files, the GitHub API, Karpathy's original post, and the Claude Code, Cursor, Codex and Antigravity docs on October 30, 2026. Everything below was re-verified against those sources.
What Are Andrej Karpathy Skills? Quick Answer
Andrej Karpathy Skills is a community GitHub repo, not an official Karpathy or Anthropic release. It contains a 65-line CLAUDE.md, a Claude Code plugin that exposes a skill named karpathy-guidelines, and a Cursor rule. All three carry the same four principles, which the README derives from Karpathy's January 26, 2026 post about LLM coding mistakes:
- Think Before Coding: state assumptions, ask when unclear, surface tradeoffs
- Simplicity First: the minimum code that solves the problem
- Surgical Changes: touch only what the request requires
- Goal-Driven Execution: define success criteria, loop until verified
Install in Claude Code (commands from the repo README; see the install steps):
/plugin install andrej-karpathy-skills@karpathy-skills
Repo facts, checked via the GitHub API on October 30, 2026: 226,645 stars, 22,632 forks, created January 27, 2026, last push April 20, 2026. The README, plugin.json and SKILL.md all say MIT, but GitHub does not detect a LICENSE file in the repo.
Get the latest on AI, LLMs & developer tools
New MCP servers, model updates, and guides like this one — delivered weekly.
🎬 Watch the Video Breakdown
Prefer reading? Keep scrolling for the full written guide with code examples.
1. Why It Went Viral
The repo was created on January 27, 2026, one day after Karpathy's post. As of October 30, 2026 the GitHub API reports 226,645 stars and 22,632 forks, for a repo whose payload is essentially one 65-line file. The last push was April 20, 2026 (a README translation sync), so the content has been stable for months.
Not a framework. Not a library. Not an app. A single set of behavioral guidelines for AI coding agents. The README, plugin.json and SKILL.md declare the MIT license, although GitHub's license detector shows none because the repo has no LICENSE file. If you plan to redistribute it inside a product, check with the maintainers first.
Why This Matters
The repo has no code to run and no runtime dependencies. Its value is the ideas, and its star count says more about demand for agent guardrails than about the file itself. Stars are not evidence that the rules improve output; see the section on evidence below.
2. The Origin Story
The repo traces directly to a viral tweet by Andrej Karpathy — co-founder of OpenAI, former AI lead at Tesla, and the person who coined the term “vibe coding.” In his post, Karpathy didn't share a tool or a repo. He shared observations — a list of frustrations with how LLMs behave when writing code.
A few random notes from claude coding quite a bit last few weeks.
— Andrej Karpathy (@karpathy) January 26, 2026
Coding workflow. Given the latest lift in LLM coding capability, like many others I rapidly went from about 80% manual+autocomplete coding and 20% agents in November to 80% agent coding and 20% edits+touchups in…
The repo's plugin manifests credit forrestchang as author. It was first published at github.com/forrestchang/andrej-karpathy-skills and now lives at github.com/multica-ai/andrej-karpathy-skills; the old URL still resolves to the new one (checked October 30, 2026), and the README carries a promotion for the maintainer's Multica project. The author converted Karpathy's observations into a structured CLAUDE.md, a file Claude Code reads at the start of every session.
Karpathy shared observations. He did not publish this repo, and the repo is not endorsed by him or by Anthropic. Karpathy's post even says that “a few simple attempts to fix it via instructions in CLAUDE.md” had not solved the problems, so treat the file as a mitigation, not a cure.
3. The Problems Karpathy Identified
Karpathy's observations weren't vague complaints. They were specific, reproducible patterns that every developer using AI coding agents has experienced. Here are his exact words:
Problem 1: Hidden Assumptions
“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.”
Problem 2: Over-Engineering
“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.”
Problem 3: Unintended Side Effects
“They still sometimes change/remove comments and code they don't sufficiently understand as side effects, even if orthogonal to the task.”
If you've used Claude Code, Copilot, Cursor, or any AI coding agent, you've felt this. You ask the agent to fix a bug, and it rewrites half the file. You ask it to add a feature, and it builds an entire abstraction layer. You ask it for help, and it confidently charges ahead with wrong assumptions.
The Reddit community (especially r/ClaudeAI and r/ClaudeCode) has a widely-used term for this behavior: “the confident junior dev.” The AI is fast, knowledgeable, and prone to making naive mistakes if left unsupervised. It's brilliant but unreliable — exactly the kind of engineer who needs clear guardrails.
4. The Four Principles
The repo author distilled Karpathy's observations into four principles. Each one directly addresses a specific class of LLM failure:
| Principle | Addresses |
|---|---|
| Think Before Coding | Wrong assumptions, hidden confusion, missing tradeoffs |
| Simplicity First | Overcomplication, bloated abstractions, speculative features |
| Surgical Changes | Orthogonal edits, touching code you shouldn't, style drift |
| Goal-Driven Execution | Vague implementation, no verification, weak success criteria |
Let's break down each one.
Principle 1: Think Before Coding
“Don't assume. Don't hide confusion. Surface tradeoffs.”
This is the most fundamental principle. LLMs have a tendency to 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
Example: The Hidden Assumption Trap
User request: “Add a feature to export user data”
def export_users(format='json'):
users = User.query.all()
# Assumed ALL users, file location, fields,
# CSV fieldnames — without asking anything
Before implementing, I need to clarify:
1. Scope: Export all users or filtered subset?
(privacy implications)
2. Format: Download file? Background job?
API endpoint?
3. Fields: Which user fields?
(some might be sensitive)
4. Volume: How many users typically?
Simplest approach: Add an API endpoint that
returns paginated JSON. What's your preference?
Principle 2: Simplicity First
“Minimum code that solves the problem. Nothing speculative.”
This combats the LLM's tendency toward over-engineering. The rules are strict:
- 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.
Example: The Over-Abstraction Trap
User request: “Add a function to calculate discount”
class DiscountStrategy(ABC):
@abstractmethod
def calculate(self, amount): ...
class PercentageDiscount(DiscountStrategy): ...
class FixedDiscount(DiscountStrategy): ...
class DiscountConfig: ...
class DiscountCalculator: ...
# 50+ lines for a single calculation
# Usage requires 30+ lines of setup
def calculate_discount(amount, percent):
"""Calculate discount. percent is 0-100."""
return amount * (percent / 100)
# Usage
discount = calculate_discount(100.0, 10.0) # $10 off
Key Insight from the Repo
“The ‘overcomplicated’ examples aren't obviously wrong — they follow design patterns and best practices. The problem is timing: they add complexity before it's needed.” Good code solves today's problem simply, not tomorrow's problem prematurely.
Principle 3: Surgical Changes
“Touch only what you must. Clean up only your own mess.”
This is the principle that most directly addresses Karpathy's frustration with LLMs making orthogonal changes. 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.
Example: The Drive-By Refactoring Trap
User request: “Fix the bug where empty emails crash the validator”
Changed 15 lines:
- Added docstring (not asked)
- Added username validation (not asked)
- Changed comments (not asked)
- “Improved” email validation logic (not asked)
- Added .strip() calls everywhere (not asked)
Changed 3 lines:
- Added empty-string guard for email
- Changed variable reference to avoid crash
- Nothing else touched.
Example: The Style Drift Trap
User request: “Add logging to the upload function”
The LLM adds logging — but also changes single quotes to double quotes, adds type hints nobody asked for, adds a docstring, reformats whitespace, and restructures the boolean return logic. The correct approach: add only the logging lines, using the existing style (single quotes, no type hints, same spacing).
Principle 4: Goal-Driven Execution
“Define success criteria. Loop until verified.”
This principle captures what Karpathy considers the highest-leverage insight about working with LLMs:
Karpathy's Key Insight
“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 principle transforms imperative tasks into declarative goals:
| Instead of... | Transform to... |
|---|---|
| “Add validation” | “Write tests for invalid inputs, then make them pass” |
| “Fix the bug” | “Write a test that reproduces it, then make it pass” |
| “Refactor X” | “Ensure tests pass before and after” |
For multi-step tasks, the model should 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.
5. The Actual CLAUDE.md File
Below is a condensed view of the repo's CLAUDE.md (the real file is 65 lines; some bullets here are shortened, and the closing “These guidelines are working if” line is omitted). Read the full file on GitHub before you copy anything:
Behavioral guidelines to reduce common LLM coding
mistakes. Merge with project-specific instructions
as needed.
Tradeoff: These guidelines bias toward caution
over speed. For trivial tasks, use judgment.
## 1. Think Before Coding
Don't assume. Don't hide confusion. Surface tradeoffs.
Before implementing:
- State your assumptions explicitly. If uncertain, ask.
- If multiple interpretations exist, present them.
- If a simpler approach exists, say so.
- If something is unclear, stop. Name what's confusing.
## 2. Simplicity First
Minimum code that solves the problem. Nothing speculative.
- No features beyond what was asked.
- No abstractions for single-use code.
- No “flexibility” that wasn't requested.
- No error handling for impossible scenarios.
- If 200 lines could be 50, rewrite it.
## 3. Surgical Changes
Touch only what you must. Clean up only your own mess.
- Don't “improve” adjacent code or formatting.
- Don't refactor things that aren't broken.
- Match existing style, even if you'd do it differently.
- If you notice dead code, mention it — don't delete it.
## 4. Goal-Driven Execution
Define success criteria. Loop until verified.
Transform tasks into verifiable goals:
- “Add validation” → “Write tests, then make them pass”
- “Fix the bug” → “Reproduce it in a test, then fix”
- “Refactor X” → “Ensure tests pass before and after”
The real file is short enough to sit in the agent's context without crowding out project-specific instructions. The same text also ships as skills/karpathy-guidelines/SKILL.md (with name, description and license: MIT frontmatter) and as .cursor/rules/karpathy-guidelines.mdc (with alwaysApply: true).
What is in the repo (file list, October 30, 2026)
| File | Purpose |
|---|---|
CLAUDE.md | The four principles, for per-project use |
.claude-plugin/marketplace.json | Marketplace named karpathy-skills, listing one plugin |
.claude-plugin/plugin.json | Plugin andrej-karpathy-skills v1.0.0, points at ./skills/karpathy-guidelines |
skills/karpathy-guidelines/SKILL.md | The skill (karpathy-guidelines) Claude can load when relevant |
.cursor/rules/karpathy-guidelines.mdc and CURSOR.md | Cursor project rule and setup notes |
EXAMPLES.md | Before/after examples for each principle |
README.md, README.zh.md | English and Chinese READMEs |
6. Real-World Examples
The repo includes an EXAMPLES.md file with detailed before/after comparisons. Here's the key “anti-patterns summary” from the file:
| Principle | Anti-Pattern | Fix |
|---|---|---|
| Think Before Coding | Silently assumes file format, fields, scope | List assumptions explicitly, ask for clarification |
| Simplicity First | Strategy pattern for a single discount calculation | One function until complexity is actually needed |
| Surgical Changes | Reformats quotes, adds type hints while fixing a bug | Only change lines that fix the reported issue |
| Goal-Driven | “I'll review and improve the code” | “Write test for bug X → make it pass → verify no regressions” |
7. How to Install Andrej Karpathy Skills in Claude Code
The README lists two methods. Both commands below are copied from the repo's README as of October 30, 2026. Claude Code's own docs describe the same two-step marketplace flow: add the marketplace, then install the plugin.
Option A: Claude Code Plugin (Recommended)
- Start Claude Code (
claude) in any project. - Add the marketplace with the first command below. This only registers the catalog; nothing is installed yet.
- Install the plugin with the second command. The skill is then available across all your projects.
- Run
/pluginto confirm it is listed. If/pluginis not recognized, update Claude Code and restart it (Anthropic's troubleshooting advice).
The marketplace name is karpathy-skills and the plugin name is andrej-karpathy-skills, which is why the install command reads andrej-karpathy-skills@karpathy-skills. Anthropic warns that plugins can run arbitrary code with your user privileges, so read the repo first. Here the plugin only points at one markdown skill file.
/plugin marketplace add forrestchang/andrej-karpathy-skills
# Then install the plugin
/plugin install andrej-karpathy-skills@karpathy-skills
Option B: CLAUDE.md (Per-Project)
For a single project:
curl -o CLAUDE.md https://raw.githubusercontent.com/
forrestchang/andrej-karpathy-skills/main/CLAUDE.md
The forrestchang URLs in the README still work (GitHub redirects to multica-ai/andrej-karpathy-skills). The raw CLAUDE.md URL returned HTTP 200 on October 30, 2026. If you want a URL that will not depend on a redirect, use multica-ai/andrej-karpathy-skills instead.
echo "" >> CLAUDE.md
curl https://raw.githubusercontent.com/forrestchang/
andrej-karpathy-skills/main/CLAUDE.md >> CLAUDE.md
Customization
These guidelines are designed to be merged with project-specific instructions. Add your own sections for TypeScript config, API standards, testing conventions, or whatever your project needs. The four principles provide the behavioral floor; your project rules build on top.
Check that Claude loaded it
For the per-project option, run /memory in a Claude Code session and look for your CLAUDE.md path in the list (Anthropic's docs describe /memory as the way to see which instruction files loaded). For the plugin option, run /plugin. Then ask Claude to “summarize your project instructions” and check that it mentions the four principles.
Use It in Other Agents: AGENTS.md, Cursor, Codex, Antigravity
The four principles are plain markdown, so they work anywhere that reads a markdown instruction file. Only the filename and loading rules change. The repo itself only ships Claude Code and Cursor packaging; the AGENTS.md steps below are our adaptation, not an official repo feature.
| Agent | Where to put the rules | Source |
|---|---|---|
| Claude Code | CLAUDE.md, or the plugin. Claude Code can also read AGENTS.md directly, but only when no CLAUDE.md exists in the working directory or above (v2.1.277+). Otherwise add @AGENTS.md inside a CLAUDE.md. | Claude Code memory docs |
| Cursor | Copy .cursor/rules/karpathy-guidelines.mdc from the repo into your project's .cursor/rules/, or use a root AGENTS.md (nested ones are supported). Cursor does not read CLAUDE.md by default, per the repo's CURSOR.md. | Cursor rules docs |
| OpenAI Codex CLI | AGENTS.md at the repo root, or ~/.codex/AGENTS.md for all repos. Combined size is capped at 32 KiB by default. | Codex AGENTS.md guide |
| Google Antigravity | AGENTS.md or GEMINI.md in the workspace root (no frontmatter needed, always on), or ~/.gemini/AGENTS.md globally. Per-file limit is 24 KB. | Antigravity rules docs |
Steps: turn the four principles into an AGENTS.md
- Download the file:
curl -o AGENTS.md https://raw.githubusercontent.com/multica-ai/andrej-karpathy-skills/main/CLAUDE.md - Open
AGENTS.mdand change the first heading fromCLAUDE.mdtoAGENTS.md. The body needs no other edits, since the rules do not mention Claude-specific features. - Append your project rules (stack, commands, conventions) under a
## Project-Specific Guidelinesheading, as the README suggests. - If you also use Claude Code, create a
CLAUDE.mdcontaining the single line@AGENTS.mdso both tools read one source of truth (the import pattern is documented by Anthropic). - Start a session in your agent and ask it to list the instructions it loaded.
Our companion guides cover Antigravity-specific rule patterns: writing Antigravity user rules with AGENTS.md and copy-paste Antigravity rules examples.
8. What is CLAUDE.md?
For those unfamiliar with the concept: CLAUDE.md is a Project Memory Card for AI coding agents. It is automatically read by Claude Code at the start of every session, providing persistent context that carries across conversations.
Think of it as the AI equivalent of onboarding documentation for a new developer — except the AI reads it every single time it starts working on your project.
Best Practices for CLAUDE.md (2026)
| Section | Content |
|---|---|
| Project Overview | 2-3 sentence summary of what the project does |
| Tech Stack | Languages, frameworks, key libraries |
| Architecture | Codebase map (source, components, config) |
| Commands | dev, build, test, lint commands |
| Coding Standards | Naming conventions, patterns, style rules |
| Safety Rules | “Never hardcode API keys,” “Don't edit /config” |
The Hierarchy
CLAUDE.md(project root) — Shared context, committed to GitCLAUDE.local.md(project root) — Private dev-specific notes (add to .gitignore)~/.claude/CLAUDE.md— Global preferences across all projects- Subdirectory
CLAUDE.mdfiles — Context pulled only when working in that directory
The rule of thumb: If you have to repeat an instruction in chat more than twice, promote it into your CLAUDE.md.
9. Community Reactions
We researched discussions across Reddit (r/ClaudeAI, r/ClaudeCode), Twitter/X, and technical blogs. Here's what the community thinks:
The “Confident Junior Dev” Consensus
The Reddit community frequently describes Claude Code as a brilliant but sometimes unreliable “junior developer.” It's fast and knowledgeable, but prone to taking dangerous shortcuts, hallucinating, or making naive mistakes if left unsupervised. The Karpathy skills file directly addresses this by adding the guardrails a junior dev needs.
The “Skill Issue” Argument
A prevailing sentiment on Reddit: the quality of AI-generated code is directly proportional to the user's own engineering judgment and “context engineering” skills. Advanced users who master prompt structure, context management, and verification loops report dramatically higher success rates. The Karpathy skills file is one of the most popular “context engineering” tools.
The “AI Psychosis” Debate
Karpathy's description of “perpetual AI psychosis” — a constant state of hyper-productive yet draining agent-direction — resonated deeply. Some see AI agents as a competitive advantage you can't afford to ignore. Others call it “productivity theater” — feeling fast while producing unmaintainable code. The skills file sits in the middle: it acknowledges that AI agents are powerful but argues they need disciplined constraints.
The Human Bottleneck Shift
The community consensus: AI has lowered the barrier to writing code. But the real bottleneck has shifted from implementation to architecture and evaluation. The challenge is no longer “how do I write this?” but “do I understand what the agent just built well enough to maintain it?”
10. The Bigger Picture
From “Vibe Coding” to “Agentic Engineering”
When Karpathy coined “vibe coding” in early 2025, it described a loose, conversational way of prompting AI. By 2026, the community has matured this into “agentic engineering” — a discipline where developers treat AI as a partner requiring clear objectives, defined boundaries, and rigorous testing.
The andrej-karpathy-skills repo represents this evolution. It's not about limiting what AI can do. It's about channeling what it can do through principles that produce better outcomes.
The “Idea File” Pattern
This repo also exemplifies what Karpathy calls the “idea file” pattern — sharing ideas rather than implementations. The CLAUDE.md file isn't a library anyone imports. It's a set of principles anyone can adapt. The recipient's agent customizes it for their specific needs. This is a new kind of open source: not open code, but open ideas.
How to Know It's Working
From the repo's README, 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”
The Tradeoff Note
The repo is honest about its tradeoffs: “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.
Is There a Better CLAUDE.md Than Karpathy's?
There is no benchmark that ranks CLAUDE.md files, so we cannot name a winner. What we can say from the sources:
- The repo ships no test results. Its README says what to look for (smaller diffs, fewer rewrites, questions before code), but it does not publish measurements. Treat any “X% fewer mistakes” claim about it, including third-party ones, as unverified unless the author shows method and data.
- It is a generic behavior layer, not a project file. It says nothing about your stack, test commands or architecture. Anthropic's docs say CLAUDE.md should hold project context such as build commands and conventions, so you still need your own sections on top.
- Karpathy himself reported limits. His post says a few simple instruction attempts in CLAUDE.md did not fix these behaviors on their own. Plan mode, tests and review still matter.
- Anthropic offers a way to audit your own file.
/doctor prompt-auditchecks CLAUDE.md, AGENTS.md and skills for outdated or conflicting instructions. Run it after pasting in any third-party rules.
If you want more rules than the four, see our extended 12-rule version of Karpathy's CLAUDE.md. For the idea-file concept behind it, see Karpathy's LLM Wiki idea file.
11. Porting Karpathy's CLAUDE.md to Antigravity Rules
Update (Oct 30, 2026): This section is kept from the March 2026 version of this guide. The core advice (save the four principles as AGENTS.md or GEMINI.md in the workspace root) matches the Antigravity rules docs linked in the table above. The claims about file precedence, the four platform surfaces and .agents/AGENTS.md in managed agents are community-reported (March 2026) and were not re-verified, so check the Antigravity rules docs before relying on them.
Because these four principles are behavioral rules rather than Claude-specific code, they port cleanly to Google Antigravity. Antigravity does not read CLAUDE.md. Instead it reads two files at the start of every agent session: AGENTS.md — the cross-tool standard that Cursor and Claude Code also honor — and GEMINI.md, Antigravity's own file, which takes precedence when the two conflict. Both are loaded as system instructions, and the same file is respected across all four surfaces of the platform: the Antigravity 2.0 IDE, the agy CLI, the Agent SDK, and managed agents run in Google's cloud sandbox (which load .agents/AGENTS.md on startup). Write the rules once and every surface inherits them. (Community-reported, March 2026.)
The mapping is nearly one-to-one. Drop Karpathy's four headings into AGENTS.md if you want them shared with Cursor and Claude Code too, or into GEMINI.md if you want them Antigravity-only:
| Karpathy CLAUDE.md principle | Equivalent AGENTS.md / GEMINI.md rule line |
|---|---|
| 1. Think Before Coding | ## Before coding — State assumptions; if the request is ambiguous, ask before editing. Surface tradeoffs instead of picking silently. |
| 2. Simplicity First | ## Code style — Ship the minimum that solves the task. No speculative abstractions, no unrequested config or error handling. |
| 3. Surgical Changes | ## Editing — Change only the lines the task requires. Match existing style. Never drive-by refactor or reformat. |
| 4. Goal-Driven Execution | ## Verification — Turn tasks into checks: write or run a test that proves the goal, then loop until it passes. |
One caveat worth noting: Karpathy's “Goal-Driven Execution” assumes the agent can run tests and loop autonomously. Antigravity's agent manager handles that loop natively, so this principle tends to pay off even more there than in a single-shot chat. For deeper, Antigravity-specific rule patterns, see our guides on writing Antigravity user rules with AGENTS.md and copy-paste Antigravity rules examples.
What changed in 2026
Two shifts have reshaped how these guidelines are used. First, Claude Code Skills reached general availability — the filesystem-based SKILL.md format is now supported across Claude Code, the Claude API, claude.ai, Cursor, and Antigravity, so a rules file written once travels between tools. Second, the community has largely retired “vibe coding” as a label for serious work; the term of art is now “agentic engineering” — treating the agent as a partner that needs explicit objectives, boundaries, and verification loops, which is exactly what Karpathy's four principles encode. (Community-reported, March 2026; the cross-tool support list was not re-verified.)
12. Frequently Asked Questions
What is Andrej Karpathy Skills on GitHub?
It is the andrej-karpathy-skills repo, now at github.com/multica-ai/andrej-karpathy-skills (originally forrestchang/andrej-karpathy-skills). It holds a CLAUDE.md, a Claude Code plugin and skill named karpathy-guidelines, and a Cursor rule, all built around four principles: Think Before Coding, Simplicity First, Surgical Changes and Goal-Driven Execution. As of October 30, 2026 it had 226,645 stars.
Is the Karpathy skills file official?
No. It is a community project whose manifests credit forrestchang as author. Its README derives the rules from Andrej Karpathy's January 26, 2026 post, but Karpathy shared the observations, not the repo, and neither Anthropic nor Karpathy publishes or maintains it. The README, plugin.json and SKILL.md declare the MIT license, though GitHub detects no LICENSE file.
How do I install Karpathy skills in Claude Code?
Run /plugin marketplace add forrestchang/andrej-karpathy-skills, then /plugin install andrej-karpathy-skills@karpathy-skills. For a single project, download the repo's CLAUDE.md into your project root with curl instead. Both methods come from the repo README.
What are the Karpathy guidelines (karpathy-guidelines skill)?
karpathy-guidelines is the name of the skill inside the plugin. Its four sections are Think Before Coding, Simplicity First, Surgical Changes and Goal-Driven Execution. Its description tells Claude to use it when writing, reviewing or refactoring code.
Can I use the Karpathy skills as AGENTS.md in Cursor, Codex or Antigravity?
Yes, with a small adaptation of our own, since the repo does not ship an AGENTS.md. Save the guidelines as AGENTS.md in your project root. Cursor, OpenAI Codex CLI and Google Antigravity all document AGENTS.md support. Claude Code reads it directly only when no CLAUDE.md is present, so add a CLAUDE.md containing @AGENTS.md if you use both.
CLAUDE.md vs AGENTS.md: what is the difference?
CLAUDE.md is Claude Code's own instruction file. AGENTS.md is a shared plain-markdown convention read by several tools. GEMINI.md is an additional file Antigravity also loads. The guidance can be identical; the filename and loading rules differ per tool.
Is there a better CLAUDE.md than Karpathy's?
No published benchmark ranks them. Karpathy's four rules are a small, popular behavior layer, but they do not replace project-specific instructions, and the repo publishes no measured results. See the section above for what to check.
Does the Karpathy skills file work in Google Antigravity?
Yes. The four principles are model-agnostic behavioral rules, not Claude-specific code. Paste them into AGENTS.md (the cross-tool standard Antigravity, Cursor, and Claude Code all read) or into GEMINI.md (Antigravity's own file). Update (Oct 30, 2026): Antigravity's rules docs document AGENTS.md and GEMINI.md in the workspace root. The earlier claims that GEMINI.md has the highest priority and that both files load as system instructions at session start are community-reported (March 2026) and were not re-verified.
CLAUDE.md vs AGENTS.md — what's the difference?
CLAUDE.md is Claude Code's project memory file. AGENTS.md is the cross-tool rules standard read by Antigravity, Cursor, and other agents. GEMINI.md is an additional file Antigravity also loads. The content is the same behavioral guidance; only the filename and loading rules differ per tool. Update (Oct 30, 2026): the earlier claim that GEMINI.md always takes precedence over AGENTS.md is community-reported (March 2026) and was not found in the current Antigravity rules docs.
13. All Sources & Links
This article was researched using multi-source research across GitHub, Twitter/X, Reddit, web articles, and the source code itself. Here are all the primary sources:
Primary Sources
- GitHub: multica-ai/andrej-karpathy-skills — The repo itself
- CLAUDE.md — The actual guidelines file
- EXAMPLES.md — Real-world before/after examples
- Karpathy's Original Tweet — The viral post identifying LLM coding pitfalls
Community Discussions
- Reddit r/ClaudeAI — Community discussions on Claude Code workflows and the “confident junior dev” consensus
- Reddit r/ClaudeCode — Threads on CLAUDE.md best practices and spec systems
- Twitter/X — Developer reactions, workflow sharing, and adoption reports
Web Sources
- Medium — Technical reviews and implementation guides
- dev.to — Developer community tutorials
- Forbes — Coverage of “vibe coding” evolution to “agentic engineering”
- VentureBeat — Analysis of Karpathy's “compiler” analogy for context management
- Analytics Vidhya — Technical analysis of the skills file's approach
Documentation
- Claude Code Documentation — Official CLAUDE.md reference
- HumanLayer.dev — Best practices for CLAUDE.md configuration
Related Articles on This Site
- Karpathy's LLM Knowledge Bases: The Original Tweet, Explained
- Karpathy's LLM Wiki: The Complete Guide to His Idea File
- How to Set Up Skills in Your AI IDE
- The Complete Guide to System Prompts for AI Agents
Subscribe to the Agentpedia newsletter
The best of the AI coding world — new agent skills, MCP servers, LLM releases and workflow tips, curated weekly.