Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

karpathy-coder

/karpathy-coder

Wymusza cztery zasady kodowania Karpathy'ego przy pisaniu i przeglądzie kodu: ujawnianie założeń przed kodowaniem, prostota, punktowe zmiany i weryfikowalne cele.

Repozytorium
claude-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
23.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
12
Skrypty
4
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 23.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 4 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/assumption_linter.py, scripts/complexity_checker.py, scripts/diff_surgeon.py, scripts/goal_verifier.py

Co robi i kiedy

Wymusza cztery zasady kodowania Karpathy'ego przy pisaniu i przeglądzie kodu: ujawnianie założeń przed kodowaniem, prostota, punktowe zmiany i weryfikowalne cele.

Wyzwalacze z opisu

review my diffcheck complexityam I overcomplicating thiskarpathy checkbefore I commit
Oryginalny opis (EN)

Use when writing, reviewing, or committing code to enforce Karpathy's 4 coding principles — surface assumptions before coding, keep it simple, make surgical changes, define verifiable goals. Triggers on "review my diff", "check complexity", "am I overcomplicating this", "karpathy check", "before I commit", or any code quality concern where the LLM might be overcoding.

Jak działa

  1. The four principles
  2. Slash command
  3. Python tools (scripts/)
  4. Sub-agent
  5. Pre-commit hook
  6. References
  7. When to relax
  8. Cross-tool compatibility
  9. Related skills (chains via context: fork)
Sekcje z nagłówków SKILL.md, w oryginale · 122 linii, 754 słów
Podgląd SKILL.md
---
name: karpathy-coder
description: Use when writing, reviewing, or committing code to enforce Karpathy's 4 coding principles — surface assumptions before coding, keep it simple, make surgical changes, define verifiable goals. Triggers on "review my diff", "check complexity", "am I overcomplicating this", "karpathy check", "before I commit", or any code quality concern where the LLM might be overcoding.
context: fork
license: MIT
metadata:
  version: 2.9.0
  author: claude-code-skills
  tags: [code-quality, discipline, karpathy, simplicity, surgical-changes, anti-patterns, review]
  compatible_tools: [claude-code, codex-cli, cursor, antigravity, opencode, gemini-cli]
---

# Karpathy Coder — Active Coding Discipline

Derived from [Andrej Karpathy's observations](https://x.com/karpathy/status/2015883857489522876) on LLM coding pitfalls. This is **not just guidelines** — it ships Python tools that detect violations, a review agent, a slash command, and a pre-commit hook.

> "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."
>
> "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."
>
> — Andrej Karpathy

## 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 you write 200 lines and it 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.**

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

## Slash command

`/karpathy-check` — Run the full 4-principle review on your staged changes.

## Python tools (`scripts/`)

All tools are stdlib-only. Run with `--help`.

| Script | What it detects |
|---|---|
| `complexity_checker.py` | Over-engineering: too many classes, deep nesting, high cyclomatic complexity, unused params, premature abstractions |
| `diff_surgeon.py` | Diff noise: lines that don't trace to the stated goal — comment changes, style drift, drive-by refactors |
| `assumption_linter.py` | Hidden assumptions in a plan: unasked features, missing clarifications, silent interpretation choices |
| `goal_verifier.py` | Weak success criteria: vague plans without verifiable checks, missing test assertions |

## Sub-agent

`karpathy-reviewer` — Runs all 4 principles against a diff. Dispatched by `/karpathy-check` or manually before committing.

## Pre-commit hook

`hooks/karpathy-gate.sh` — runs `complexity_checker.py` and `diff_surgeon.py` on staged files. Warns (non-blocking) when violations are found. Wire it via `.claude/settings.json` or Husky.

## References

- `references/karpathy-principles.md` — the source quotes, deeper context, when to relax each principle
- `references/anti-patterns.md` — 10+ before/after examples across Python, TypeScript, and shell
- `references/enforcement-patterns.md` — how to wire hooks, CI integration, team adoption

## When to relax

These principles bias toward **caution over speed**. For trivial tasks (typo fixes, obvious one-liners), use judgment. The principles 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

## Cross-tool compatibility

Installs via plugin for Claude Code. For other tools, copy the principles into your schema file:

| Tool | Schema file |
|---|---|
| Claude Code | `CLAUDE.md` (auto-loaded by plugin) |
| Codex CLI | `AGENTS.md` |
| Cursor | `AGENTS.md` or `.cursorrules` |
| Antigravity / OpenCode / Gemini CLI | `AGENTS.md` |

## Related skills (chains via `context: fork`)

- **`self-eval`** — honest quality scoring after completing work
- **`code-reviewer`** — broader code review; karpathy-coder focuses on the 4 LLM-specific pitfalls
- **`llm-wiki`** — compound knowledge; karpathy-coder ensures you don't overcomplicate while building it
Pliki w paczce (12)
  • SKILL.md 6 KB
  • expected_outputs/assumption_linter.json 1 KB
  • expected_outputs/complexity_checker.json 1 KB
  • expected_outputs/diff_surgeon.json 1 KB
  • expected_outputs/goal_verifier.json 1 KB
  • references/anti-patterns.md 5 KB
  • references/enforcement-patterns.md 4 KB
  • references/karpathy-principles.md 4 KB
  • scripts/assumption_linter.py 7 KB
  • scripts/complexity_checker.py 11 KB
  • scripts/diff_surgeon.py 8 KB
  • scripts/goal_verifier.py 6 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · alirezarezvani/claude-skills100MIT
420company/artemis100MIT

Migawka bazy z 13.11.2026 · wersja paczki bad4b967398a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100karpathy-guidelines
    Wprowadza wytyczne wynikające z obserwacji Andreja Karpathy'ego o pułapkach kodowania z LLM: unikanie komplikacji, chirurgiczne zmiany, ujawnianie założeń i weryfikowalne kryteria sukcesu.
  • 100guidelines-karpathy
    Zawiera wytyczne zachowania ograniczające typowe błędy LLM w kodowaniu: unikanie nadmiernej komplikacji, punktowe zmiany, jawne założenia i weryfikowalne kryteria sukcesu.
  • 100andrej-karpathy
    Daje wskazówki behawioralne ograniczające typowe błędy kodowania LLM: unikanie nadmiernej komplikacji, chirurgiczne zmiany, ujawnianie założeń i mierzalne kryteria sukcesu.
  • 100karpathy-guidelines
    Wprowadza zabezpieczenia zachowania dla kodowania z LLM: unikanie nadmiernej komplikacji, chirurgiczne zmiany, wczesne ujawnianie założeń i wykonanie według weryfikowalnych kryteriów sukcesu.
  • 100karpathy-guidelines
    Stosuje wytyczne ograniczające typowe błędy LLM w kodzie: unikanie nadmiernej komplikacji, precyzyjne zmiany, ujawnianie założeń i definiowanie weryfikowalnych kryteriów sukcesu.
  • 100karpathy-guidelines
    Wprowadza wytyczne ograniczające typowe błędy LLM w kodowaniu: unikanie komplikacji, chirurgiczne zmiany, ujawnianie założeń i definiowanie weryfikowalnych kryteriów sukcesu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.