Karpathy's LLM coding critique gets fixed in a single CLAUDE.md file

The three habits Karpathy flagged

Karpathy pointed to three recurring patterns in how LLMs write code. "The model makes the wrong assumption on the user's behalf and just runs with it without checking," he wrote — meaning it doesn't manage ambiguity, doesn't ask for clarification, and doesn't surface contradictions or tradeoffs. The second is over-engineering: turning a 100-line job into more than 1,000 lines and leaving dead code behind instead of cleaning it up. The third is side effects — changing or deleting comments and code unrelated to the request, often without fully understanding them first.

The four principles in CLAUDE.md

The repository organizes its response to these three problems into four principles.

Principle	Key phrase	What it means
No assumptions	"Don't assume. Don't hide confusion. Surface tradeoffs."	Instead of quietly deciding on an interpretation and moving forward, the model surfaces uncertainty and tradeoffs upfront
Minimum code	"Minimum code that solves the problem."	A guard against over-engineering, with the standard: "if it looks excessive to a senior engineer, simplify it"
Minimum edits	"Touch only what you must. Clean up only your own mess."	Keeps the model from touching code unrelated to the request, and requires every changed line to trace back to the request
Success criteria	"Define success criteria. Loop until verified."	Turns an imperative instruction into a verifiable goal, letting the model iterate on its own and check against that standard

The fourth principle echoes another of Karpathy's observations: give the model a clear goal and it will iterate on its own to hit it, but hand it a loose standard like "make it work" and you'll end up asking follow-up questions endlessly.

How to use it

The multica-ai/andrej-karpathy-skills repository lays out two installation paths. The recommended one is a Claude Code plugin. Add the marketplace inside Claude Code first, and the guidelines install as a plugin — applying not just to one project but to every project you open with Claude Code. The second path is Cursor. The repo includes a .cursor/rules/karpathy-guidelines.mdc rules file, so opening a project in Cursor applies the same principles automatically. Setup instructions for Cursor are laid out separately in the repo's CURSOR.md document.

If a project already has its own CLAUDE.md, these four principles can simply be merged into it, and any project-specific rules can be added as a section below the core guidelines. The repository notes that the goal isn't to make every small task, like fixing a typo, feel heavyweight — it's to cut down on mistakes that are hard to walk back.

Building a rules file and sharing it across multiple coding agents has the advantage of not being tied to one specific model, letting teams reuse their working principles wherever they go.

The post announcing the repository also introduced a separate open-source project from the same creator, called Multica — described as a platform for running and managing coding agents using reusable skills. It's a distinct project from the CLAUDE.md repository.

Editor's view

What makes this repository interesting isn't that it turned one person's observations into rules — it's that it shows just how identical the pain points are for anyone using coding agents in real work. Whether it's Claude Code or Cursor, the same complaints keep surfacing regardless of the model: "it quietly assumes something and barrels ahead," or "it turns a 100-line job into 1,000 lines." These aren't bugs specific to one model — they look more like habits shared across LLM coding agents in general, and this case shows that a single guidelines file can go a fair way toward correcting them.

Anyone who's put a coding agent of similar scale to real work will recognize the pattern. Give it a loose goal like "just make it work," and instead of asking clarifying questions, the agent barrels ahead with its own interpretation — and reviewing the result ends up taking even more time. Give it a verifiable standard instead, like "success means this function produces this output for this input," and you can watch the agent iterate on its own toward that bar. The fourth principle in this CLAUDE.md is aimed at exactly that gap.

For teams in Korea building with Claude Code or Cursor, adding a guidelines file like this to a project costs almost nothing. But getting real value out of it means first cataloging the mistakes that actually keep recurring on your team — leaving dead code in place, touching unrelated files — and then tailoring the principles to address them. Copying someone else's rules wholesale only gets you halfway there.

In the weeks ahead, expect to see more of this kind of thing: CLAUDE.md files and skill files that distill one person's observations or one team's experience into shareable form. As the open-source community settles into trading rules files instead of prompts, it's likely that developers like Anthropic will eventually fold the best-proven rules into their default system prompts.