karpathy-coder

---
name: karpathy-coder
description: Use when writing, reviewing, or committing code to enforce Karpathy's 4 coding principles: surface assumptions, keep it simple, make surgical changes, and define verifiable goals before coding.
category: Engineering
version: 1.0.0
tools: []
---

# Karpathy Coder — Active Coding Discipline

Derived from Andrej Karpathy's observations on LLM coding pitfalls: models make wrong assumptions and run with them without checking, don't manage confusion, don't seek clarification, don't surface inconsistencies, don't present tradeoffs, and don't push back when they should. They also tend to overcomplicate code and APIs, bloat abstractions, and implement 1000-line solutions when 100 would do — even though LLMs are exceptionally good at looping until they meet specific, well-stated success criteria.

## The Four Principles

### 1. Think Before Coding

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

- State assumptions explicitly. If uncertain, ask.
- If multiple interpretations exist, present them — don't pick silently.
- If a simpler approach exists, say so. Push back when warranted.
- If something is unclear, stop. Name what's confusing. Ask.

### 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" or "configurability" that wasn't requested.
- No error handling for impossible scenarios.
- If a 200-line solution could be 50 lines, 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.**

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

| 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]
```

## Review Checks to Apply

When reviewing a diff or plan against these principles, check for:

- Over-engineering: too many classes, deep nesting, high cyclomatic complexity, unused parameters, premature abstractions
- Diff noise: lines that don't trace to the stated goal — comment changes, style drift, drive-by refactors
- Hidden assumptions in a plan: unasked features, missing clarifications, silent interpretation choices
- Weak success criteria: vague plans without verifiable checks or test assertions

## When to Relax

These principles bias toward caution over speed. For trivial tasks (typo fixes, obvious one-liners), use judgment. They matter most on:

- Non-trivial implementations (>20 lines changed)
- Code you don't fully understand
- Multi-step tasks with unclear requirements
- Anything that will be reviewed by humans

## Related Disciplines

- Honest quality scoring after completing work (self-evaluation)
- Broader code review beyond these 4 LLM-specific pitfalls
- Avoiding overcomplication while building compound knowledge over time