andrej-karpathy-skills README

The project's README from github.com/multica-ai/andrej-karpathy-skills. As one markdown file: README.md.

Karpathy-Inspired Claude Code Guidelines

Check out my new project 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 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:

Principle Addresses
Think Before Coding Wrong assumptions, hidden confusion, missing tradeoffs
Simplicity First Overcomplication, bloated abstractions
Surgical Changes Orthogonal edits, touching code you shouldn't
Goal-Driven Execution Leverage through tests-first, verifiable success criteria

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:

2. Simplicity First

Minimum code that solves the problem. Nothing speculative.

Combat the tendency toward overengineering:

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:

When your changes create orphans:

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:

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, 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:

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

Existing project (append):

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:

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:

## 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

andrej-karpathy-skills (multica-ai/andrej-karpathy-skills)

markdown
Searching Database…

220.7K ·GitHub
Andrej-karpathy-skills
What is this?A single CLAUDE.md file (also distributable as a Claude Code plugin) that encodes four guidelines derived from Andrej Karpathy's observations on common LLM coding pitfalls, meant to make Claude Code behave more carefully and avoid overengineering.
Is this a plugin, a markdown file, or both?Both — you can install it as a Claude Code plugin via a marketplace (recommended), or just copy/append the guidelines into your own project's CLAUDE.md file. A matching Cursor project rule is also included.
How do I add these guidelines to my setup?From within Claude Code, add the marketplace and install the plugin so the skill is available across all your projects, or manually create/append a CLAUDE.md in a specific project. Cursor users get the same rules via the committed .cursor/rules/karpathy-guidelines.mdc file.
Does this replace my own project-specific CLAUDE.md rules?No, it's meant to be merged with your existing instructions rather than replace them, and the author notes the rigor can be relaxed for trivial tasks like typo fixes.
What are the four core principles?Think Before Coding, Simplicity First, Surgical Changes, and Goal-Driven Execution — each targets a specific failure mode Karpathy described, from silently assuming wrong intent to bloated abstractions, unrelated edits, and unverified fixes.
How do I know the guidelines are actually working?You should notice fewer unnecessary changes in diffs, fewer rewrites caused by overcomplication, clarifying questions asked before implementation rather than after mistakes, and cleaner, more minimal PRs.
Does this work with Cursor too?Yes, the repo ships a committed Cursor project rule (.cursor/rules/karpathy-guidelines.mdc) so the same guidelines apply when the project is opened in Cursor, with setup details in CURSOR.md.
Who is Andrej Karpathy in this context?He's the AI researcher whose public observations about LLM coding pitfalls — wrong assumptions, bloated abstractions, and unrequested edits — directly inspired the four principles in this file.
What are similar projects?pstack, everything-claude-code, SwiftUI-Agent-Skill, agents, marketingskills, i-have-adhd, headcount, evondevKit
Which topics is it in?cursor-rules, claude-code-plugin, best-practices, prompt-engineering, cursor, skills, anthropic, coding-agent, claude, markdown, agent-skills, productivity
Creator
multica-ai
Size
<0.1 MB
Stars
220.7K
Updated
CommitApr 20
Age
8mo
Commits · 90 Days