forrestchang/andrej-karpathy-skills: Trending on GitHub

Trending on GitHub: Karpathy-Inspired Claude Code Guidelines

In the world of Large Language Models (LLMs), coding pitfalls are a common occurrence. Andrej Karpathy, a renowned researcher, has identified several issues that LLMs tend to struggle with, including making wrong assumptions, overcomplicating code, and not seeking clarifications. To address these problems, a single CLAUDE.md file has been created to improve Claude Code behavior. This file, inspired by Karpathy's observations, outlines four principles that directly address these issues.

The Problems

From Andrej's post, we can see that LLMs often:

• Make wrong assumptions on behalf of the user and run along with them without checking.
• Don't manage their confusion, don't seek clarifications, don't surface inconsistencies, don't present tradeoffs, don't push back when they should.
• Overcomplicate code and APIs, bloat abstractions, don't clean up dead code, and implement a bloated construction over 1000 lines when 100 would do.
• Sometimes change or remove comments and code they don't sufficiently understand as side effects, even if orthogonal to the task.

The Solution

The four principles outlined in the CLAUDE.md file directly address these issues:

1. Think Before Coding: Don't assume. Don't hide confusion. Surface tradeoffs.
2. Simplicity First: Minimum code that solves the problem. Nothing speculative.
3. Surgical Changes: Touch only what you must. Clean up only your own mess.
4. Goal-Driven Execution: Define success criteria. Loop until verified.

The Four Principles in Detail

1. Think Before Coding

Don't assume. Don't hide confusion. Surface tradeoffs.

• 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

2. Simplicity First

Minimum code that solves the problem. Nothing speculative.

• Combat the tendency toward overengineering:
  • 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.

3. Surgical Changes

Touch only what you must. Clean up only your own mess.

• 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.

4. Goal-Driven Execution

Define success criteria. Loop until verified.

• Transform imperative tasks into verifiable goals:
  • Instead of "Add validation", write "Write tests for invalid inputs, then make them pass"
  • Instead of "Fix the bug", write "Write a test that reproduces it, then make it pass"
  • Instead of "Refactor X", write "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]

Install

You can install the guidelines as a Claude Code plugin or add them to your existing CLAUDE.md file.

Option A: Claude Code Plugin (recommended)

1. From within Claude Code, first add the marketplace:
   • /plugin marketplace add forrestchang/andrej-karpathy-skills
2. Then install the plugin:
   • /plugin install andrej-karpathy-skills@karpathy-skills

Option B: CLAUDE.md (per-project)

1. New project:
   • curl -o CLAUDE.md https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md
2. Existing project (append):
   • echo "" >> CLAUDE.md
   • curl https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md >> CLAUDE.md

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:

• 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"

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

Requirements

To write a comprehensive and well-structured article, follow these requirements:

1. MINIMUM 800 words - comprehensive coverage
2. Use clear section headings (##) to organize content
3. Write in an engaging, journalistic style
4. Include technical details but make them accessible
5. Provide practical insights and implications
6. Use markdown formatting for structure
7. NO fluff or filler - every sentence should add value
8. Focus on "why this matters" and real-world applications
9. Include specific examples where relevant
10. End with forward-looking thoughts or implications

Source: https://github.com/forrestchang/andrej-karpathy-skills