SkillHub

Skills multica-ai andrej-karpathy-skills

karpathy-guidelines

Use it when:
The agent overcomplicates code, guesses silently, or edits lines you didn't ask it to touch.
It does:
Applies four rules while it writes, reviews or refactors: think before coding, simplicity first, surgical changes, goal-driven execution.
You get:
Questions instead of silent guesses, smaller diffs, and multi-step work stated as a short plan with a check for each step.
Tradeoff:
It favors caution over speed; for trivial tasks it tells the agent to use judgment.

TL;DR

Four short rules drawn from Andrej Karpathy's observations on the mistakes LLMs make when coding. Think before coding: state assumptions, lay out competing interpretations instead of picking one silently, say when a simpler approach exists, and stop to ask when something is unclear. Simplicity first: no features, abstractions, configurability or error handling nobody asked for; if 200 lines could be 50, rewrite them. Surgical changes: don't improve adjacent code, comments or formatting, match the existing style, mention unrelated dead code instead of deleting it, and remove only what your own change left unused, so every changed line traces to the request. Goal-driven execution: turn a task into something checkable, such as a test that reproduces a bug before the fix, and for multi-step work state a brief plan with a verification for each step, so the agent can loop until the checks pass.

Summarizes the skill at 2c60614.

npx skills add https://github.com/multica-ai/andrej-karpathy-skills --skill karpathy-guidelines

skills.sh pageSource on GitHubAll skills from multica-ai/andrej-karpathy-skills

Total Downloads
45,400 on skills.sh, Nov 9, 2026
Repo stars
231,008 multica-ai/andrej-karpathy-skills
First seen
Jan 28, 2026 on skills.sh
Weekly Downloads
1.4K
+39% over the 8 weeks to Nov 9
Weekly values
Week toInstalls
Sep 211,035
Sep 281,045
Oct 51,075
Oct 12945
Oct 191,259
Oct 261,676
Nov 21,307
Nov 91,443
Category
category:engineeringcategory:software-engineering

Test-first work, implementation from specs, git hygiene and scope control.

Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type
type:guidelines

Knowledge and rules the agent applies while it works: best practices, design principles, API references.
Effect
effect:none

Adds no side effects of its own. It shapes how the agent thinks, writes or reviews. Guidelines and routers are always effect:none, even when the task they support edits code.
Needs
needs:none

Instructions only. Works in any agent that supports skills.
Publisher
by:community

Everyone else. Unverified vendor claims default to community.
Topics
scope-controlcode-qualityverification

SKILL.md

From multica-ai/andrej-karpathy-skills at 2c60614. Checked daily, last changed Nov 6, 2026.

Frontmatter
name: karpathy-guidelines
description: Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
license: MIT

Karpathy Guidelines

Behavioral guidelines to reduce common LLM coding mistakes, derived from Andrej Karpathy's observations on LLM coding pitfalls.

Tradeoff: These guidelines bias toward caution over speed. For trivial tasks, use judgment.

1. Think Before Coding

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

Before implementing:

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

Ask yourself: "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 tasks into verifiable goals:

  • "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 you loop independently. Weak criteria ("make it work") require constant clarification.