220,000 Developers Starred a Text File.

Let me tell you about the most-starred AI repository of 2026.

It has no code. No dependencies. No installation script. No framework to learn. It is a single plain text file, 70 lines long, that you drop into the root of your project. The repository forrestchang/andrej-karpathy-skills has accumulated over 220,000 combined GitHub stars across two accounts approximately 91,200 on Forrest Chang’s personal account and over 132,000 on the organisation mirror at multica-ai/andrej-karpathy-skills since it was created on January 27, 2026. It appeared on GitHub Trending for weeks on end, with the organisation mirror reaching the number one position on April 8, 2026. It has been installed by developers across every major language, framework, and industry.

The file is called CLAUDE.md. It contains 4 behavioral rules for AI coding agents, when I first read those rules, my immediate reaction was that these are obvious. Every senior engineer would tell a junior these things on day one. Why does a text file stating obvious things become the most viral AI repository of the year?

The answer to that question is more interesting than the file itself.

Where This Came From and Why It Spread the Way It Did

On January 26, 2026, Andrej Karpathy posted on X about what he called the biggest change to his basic coding workflow in two decades of programming. Karpathy is not a casual observer of this space. He is a co-founder of OpenAI, the former Director of AI at Tesla, a Stanford PhD, and the person who coined the term vibe coding in early 2025. When he says something changed his workflow, people pay attention.

What he described was a shift from 80% manual coding with autocomplete to 80% agent-driven development in roughly 2 months. He had made the same transition that millions of developers were making around the same time, following what he described as a phase shift in software engineering that happened around December 2025, when agentic coding tools crossed a threshold of coherence that made them genuinely useful for production work rather than just demos.

But the post was not celebratory. It was a precise inventory of failure modes. Karpathy wrote: “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.” He identified 4 specific recurring patterns of failure that he kept encountering. Silent wrong assumptions. Overcomplicated solutions with unnecessary abstractions. Unauthorised edits to code adjacent to the requested task. Vague instructions being executed without defining what success would look like.

The post gathered significant attention across the developer community. The following day, developer Forrest Chang did something practical with it. He took Karpathy’s observations and encoded them into a CLAUDE.md file, 4 named principles each addressing one failure mode Karpathy had identified. The repo crossed 43,000 stars in its first week, reached 110,000 by early May on the personal account alone, and passed 220,000 combined stars with the organisation mirror by mid-May 2026.

Stack Overflow’s 2025 developer survey found that 84% of developers now use AI coding tools, but trust in AI output had fallen from 40% to 29% year over year. That gap between usage and trust is the precise tension the CLAUDE.md file addresses. People kept using the tools because the productivity benefit was real. People stopped trusting the output because the failure modes were predictable and consistent. Karpathy named those failure modes precisely. Chang turned the names into a configuration file. The community recognised both in the same instant.

The 4 Rules and Why Each One Exists

Before going into each rule, it helps to understand what a CLAUDE.md file actually is. Claude Code, Anthropic’s coding agent, reads any file named CLAUDE.md in the project root at the start of every session. It treats the contents as persistent context for that project. The file gets committed to version control, so every developer on the team gets the same behavioral guardrails automatically. Zero configuration beyond creating the file.

The karpathy-skills CLAUDE.md does not contain project-specific instructions about naming conventions or testing frameworks. It contains behavioral principles generic enough to drop into any codebase and immediately change how the agent approaches tasks.

Rule One: Think Before Coding

This rule addresses what researchers call the silent assumption problem. A 2025 academic study cited by ByteIota found that 94% of LLM compilation errors are type-check failures, where the model assumed a type rather than asking for clarification. The pattern is consistent across every kind of ambiguity, not just types. You ask the agent to add validation. It picks a validation level without asking which one you need. You ask it to refactor a function. It picks an approach without checking whether you have constraints that would rule it out.

The rule requires the agent to state its assumptions explicitly before writing any code, present multiple interpretations when a request is ambiguous, and ask rather than guess when something is genuinely unclear. One good clarifying question at the start of a task eliminates five rounds of revision at the end. The principle sounds obvious because it is. The model does not follow it by default. That gap is the entire problem.

Rule Two: Simplicity First

Karpathy described this failure directly in his post: “They really like to overcomplicate code and APIs, bloat abstractions, don’t clean up dead code… implement a bloated construction over 1,000 lines when 100 would do.” The rule requires the agent to write the minimum code that solves the problem, avoid speculative abstractions, and treat over-engineering as a failure rather than thoroughness. The test: would a senior engineer call this overcomplicated? If yes, rewrite it.

Rule Three: Surgical Changes

This is the rule that addresses what Karpathy called collateral damage that the agent editing code it was never asked to touch. I have experienced this in specific enough ways that I can describe it precisely. You ask an agent to fix a date parsing bug. It fixes the bug. It also reformats the entire file, switches unrelated functions from list comprehensions to loops, adds type hints to functions in a different module, and renames a variable it thought was unclear. None of that was requested. All of it now requires review.

Karpathy described this pattern exactly: “They still sometimes change/remove comments and code they don’t sufficiently understand as side effects, even if orthogonal to the task.” The rule requires the agent to touch only what the task requires, leave neighbouring code exactly as found, and trace every changed line back to the original request. If a line changed and cannot be traced to the task, it should not have changed.

Rule Four: Goal-Driven Execution

This rule addresses the absence of verifiable success criteria. Vague instructions like add validation or fix the bug give the agent no way to know when it has finished, which produces either premature stops or endless iteration. As the CLAUDE.md guide on Medium describes it, clear success criteria let the model iterate autonomously. Vague criteria require intervention at every step.

The rule requires the agent to turn vague instructions into verifiable targets before writing a line. Add validation becomes write tests for invalid inputs, then make them pass. Fix the bug becomes write a test that reproduces the issue, then make the test pass. The shift from imperative to goal-based is not stylistic. It changes the model’s ability to evaluate its own output.

What the Star Count Is Actually Measuring

220,000 combined stars on a plain text file is not a vote on the file. It is a vote on the problem. Every developer who read Karpathy’s post recognised the failures he described from their own sessions. The file went viral because the bar for adoption was that can I copy-paste this into my repo right now. The answer was yes. So hundreds of thousands of people did.

The context matters. ByteIota’s analysis of AI coding adoption found that 68% of developers now use AI to generate code, with 1.1 million public repositories importing an LLM SDK, up 178% year over year. Nearly 80% of new developers use Copilot within their first week. Karpathy himself noted that 2026 was on track to become what he called the slopacolypse: a flood of low-quality AI-generated code produced by agents operating without behavioral guardrails.

TypeScript becoming GitHub’s number one language in 2026, with 66% growth driven by 2.6 million monthly contributors, is partly a response to this. When AI writes more of your code, type safety matters more, because the agent makes type errors consistently, and a type system catches them before they ship. The four rules in CLAUDE.md are addressing the same problem at the behavioral layer rather than the language layer.

The most viral AI tool of the month was not a new model. It was a document telling an existing model to behave like a thoughtful engineer rather than a confident one.

The Honest Caveats Worth Stating Clearly

The file is behavioral context, not a contract. Claude Code reads CLAUDE.md and treats it as instruction. It does not always follow it. The principles improve the distribution of behavior. They do not guarantee specific behavior on any given task. Reddit threads pointing this out are correct.

The accuracy improvement numbers that circulate online come from specific skill evaluations documented by ByteIota covering particular domains. Those are not general coding accuracy figures and should not be treated as such. The directional claim, that the file improves output quality meaningfully, is supported by widespread developer reports. The specific numbers are context-dependent.

The principles are not Claude-specific. The same 4 rules, with the filename changed to match the tool, work as Cursor rules or as a system prompt prefix for any coding agent. The viral repo ships both versions. The interesting thing is not the specific tool integration. It is the principles themselves, which describe how any coding agent should behave when given real work in a real codebase.

Karpathy did not write the file. He posted the observations on January 26. Forrest Chang turned them into a repo the following day. A Snyk audit of the agent skills ecosystem published in February 2026 found that 13% of agent skills packages contained critical security flaws. Security researchers at Adversa AI and LayerX additionally documented that malicious CLAUDE.md files planted in cloned repositories can instruct Claude Code to exfiltrate SSH keys and API credentials. The practical implication is simple that install the file only from the official repositories, specifically forrestchang/andrej-karpathy-skills or multica-ai/andrej-karpathy-skills. The file is 70 lines of plain text, human-readable end to end, and takes under a minute to inspect before installing.

The repo is a starting point, not a complete configuration. The four rules work as a behavioral baseline. They do not replace project-specific instructions about naming conventions, testing frameworks, or architecture decisions. The right approach is to append a behavioral guidelines section to whatever CLAUDE.md you already have rather than replacing it with the Karpathy file.

The Deeper Point Nobody Is Talking About

The energy in AI tooling right now goes into more layers. More model capability. More context window. More integrations. More plugins. At Anthropic itself, the majority of code is now written by Claude Code, with engineers focusing on architecture, product thinking, and continuous orchestration rather than implementation. The trajectory of the industry is toward agents that do more, autonomously, with less human intervention.

The CLAUDE.md phenomenon runs in the opposite direction. It is not adding capability. It is adding constraint. It is saying: before the agent does anything, it should think. Before it writes, it should ask. Before it changes, it should verify the scope. Before it finishes, it should confirm it has met a verifiable goal.

These are not novel ideas. They are what thoughtful human engineers do automatically, after years of experience teaching them what the consequences of not doing those things look like. The gap between a model that has processed more code than any human has ever read and a model that behaves like an experienced engineer is precisely this: the experienced engineer knows when to stop, when to ask, when the solution is too complicated, when the scope has drifted. The model does not know those things by default.

The best coding agent improvement of 2026 so far is a markdown file. One developer who installed it described the setup time as four minutes and said the behavioral change was noticeable from the first task. Another described months of correcting the same session-to-session mistakes eliminated overnight by a 70-line file.

The lesson here is not that configuration beats capability. It is that capability without behavioral structure produces the specific failure modes Karpathy documented. The model is capable enough to do good work. The default behavior does not consistently produce good work. A plain text file closing that gap is not a sign that the model is limited. It is a sign that the model is powerful enough that the difference between directed and undirected is the entire gap between good output and frustrating output.

If you use Claude Code for any real work, the file is worth installing. Not because it is magic. Because the four problems it solves are the four problems you have already encountered, and naming them precisely is more than half of fixing them.