New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Karpathy Guidelines

by clabernetes in clabernetes/clabernetes

Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals.

BSD-3-ClauseAuto-check passedDevelopment

Install Karpathy Guidelines

skills CLI
$ npx skills add clabernetes/clabernetes --skill karpathy-guidelines -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install clabernetes/clabernetes karpathy-guidelines --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/clabernetes/clabernetes.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/karpathy-guidelines .claude/skills/karpathy-guidelines && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
karpathy-guidelines
GitHub stars
143
Token cost
~648 tokens
SKILL.md length
311 words
Files
2
Skills in repo
2
Repo updated
First seen
Licence
BSD-3-Clause

At a glance

Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals.

  • Works in 4 steps: Think Before Coding → Simplicity First → Surgical Changes → …
  • Project configuration
  • SKILL.md covers 1. Think Before Coding, 2. Simplicity First, 3. Surgical Changes and 4. Goal-Driven Execution
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Karpathy Guidelines is an agent skill from clabernetes/clabernetes. Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals. Use when implementing, debugging, reviewing, refactoring, or changing code or project configuration. Do not use for purely factual questions or non-engineering tasks.

Its SKILL.md is about 650 tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

It sits in Development, covering Refactoring. The repository describes itself as: containerlab, but in kubernetes! The licence is BSD-3-Clause.

When your agent uses it

  • Project configuration
  • Purely factual questions
  • Non-engineering tasks

Example prompts

  • “/karpathy-guidelines”

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Think Before Coding
  2. Simplicity First
  3. Surgical Changes
  4. Goal-Driven Execution

What it can do on your machine

Read from SKILL.md and the folder at commit 20ba632. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Karpathy Guidelines loads about 648 tokens when it runs. Until then it costs about 95 tokens; SKILL.md has 311 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~95
When it runs · the whole SKILL.md, loaded when a task matches
~648

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from clabernetes/clabernetes at commit 20ba632, republished under its BSD-3-Clause licence (© clabernetes). 311 words, ~648 tokens.

Download SKILL.mdSave it as .claude/skills/karpathy-guidelines/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
karpathy-guidelines
description
Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals. Use when implementing, debugging, reviewing, refactoring, or changing code or project configuration. Do not use for purely factual questions or non-engineering tasks.

Karpathy Guidelines

Use these guidelines while writing, reviewing, or refactoring code. They bias toward caution over speed; use judgment for trivial tasks.

1. Think Before Coding

Do not assume. Do not hide confusion. Surface tradeoffs.

Before implementing:

  • State assumptions explicitly. If uncertain, ask.
  • If multiple interpretations exist, present them; do not pick silently.
  • If a simpler approach exists, say so. Push back when warranted.
  • If something is unclear, stop, name what is confusing, and ask.

2. Simplicity First

Write the minimum code that solves the problem. Add nothing speculative.

  • Add no features beyond what was asked.
  • Create no abstractions for single-use code.
  • Add no flexibility or configurability that was not requested.
  • Add no error handling for impossible scenarios.
  • If 200 lines could be 50, rewrite them.

Ask: "Would a senior engineer say this is overcomplicated?" If yes, simplify.

3. Surgical Changes

Touch only what is necessary. Clean up only effects of the current change.

When editing existing code:

  • Do not improve adjacent code, comments, or formatting without a task-related reason.
  • Do not refactor things that are not broken.
  • Match the existing style, even if another style is preferable.
  • Mention unrelated dead code; do not delete it.

When the change creates orphans:

  • Remove imports, variables, functions, and files made unused by this change.
  • Do not remove pre-existing dead code unless asked.

Every changed line should trace directly to the user's request.

4. Goal-Driven Execution

Define success criteria and loop until verified.

Transform requests into verifiable goals:

  • "Add validation" means write a check for invalid inputs, then make it pass.
  • "Fix the bug" means reproduce it with a test or focused check, then make it pass.
  • "Refactor X" means verify relevant behavior before and after.

For multi-step work, use a brief plan in which every step names its verification:

text
1. [Step] -> verify: [check]
2. [Step] -> verify: [check]
3. [Step] -> verify: [check]

Strong success criteria enable independent execution. "Make it work" is not a success criterion.

© clabernetes, BSD-3-Clause. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in .agents/skills/karpathy-guidelines of clabernetes/clabernetes.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit 20ba632

Compare with similar skills

Karpathy Guidelines next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Karpathy Guidelines compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Karpathy Guidelines this skillclabernetes/clabernetes143—~648Automated safety check: PassBSD-3-Clause
Guidelinesakash-network/node1.1k20 repos~577Automated safety check: PassMIT
Component Refactoringlangflow-ai/langflow155k—~3.5kAutomated safety check: PassMIT
Migrate Core Code to Submodulestinyhumansai/openhuman42k—~2.6kAutomated safety check: PassGPL-3.0
ast-grep Structural Searchcode-yeongyu/oh-my-openagent70k—~3.3kAutomated safety check: PassMIT
Systematic Code Refactoringluongnv89/claude-howto42k—~3kAutomated safety check: PassMIT

Similar skills

  • Guidelines

    akash-network/node

    Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.

    1.1k GitHub starsUsed in 20 repos~577 tokens
    DevelopmentAuto-check passed

  • Component Refactoring

    langflow-ai/langflow

    Refactor high-complexity React components in Langflow frontend.

    155k GitHub stars~3.5k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Migrate Core Code to Submodules

    tinyhumansai/openhuman

    Plans and carries out moving non-host-specific code and its tests from the OpenHuman core into vendored tiny submodule libraries, then releases the submodule and re-pins the host.

    42k GitHub stars~2.6k tokensUpdated today
    DevelopmentAuto-check passed

  • ast-grep Structural Search

    code-yeongyu/oh-my-openagent

    Searches and rewrites code by syntax-tree shape across 25 languages with ast-grep, for codemods, structural queries and YAML lint rules, using a Python wrapper script.

    70k GitHub stars~3.3k tokensUpdated today
    DevelopmentAuto-check passed

  • Systematic Code Refactoring

    luongnv89/claude-howto

    Guides refactoring in phases based on Martin Fowler's method: research, test coverage check, planning and small tested steps, with your approval at each phase.

    42k GitHub stars~3k tokensUpdated 9 days ago
    DevelopmentAuto-check passed

  • Codex

    skills-directory/skill-codex

    A skill your agent uses when the user asks to run Codex CLI (codex exec, codex resume) or references OpenAI Codex for code analysis, refactoring, or automated editing

    1.5k GitHub starsUsed in 3 repos~1.8k tokens
    DevelopmentAuto-check passed

More from clabernetes/clabernetes

  • Test Fumadocs Wrangler

    clabernetes/clabernetes

    Builds and validates the Fumadocs React Router static site through Wrangler with headless browser checks.

    143 GitHub stars~569 tokensUpdated 5 days ago
    Auto-check passed

Categories

Questions about Karpathy Guidelines

What does Karpathy Guidelines do?

Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals. Karpathy Guidelines is an agent skill from clabernetes/clabernetes. Apply Karpathy behavioral guidelines to software engineering work by surfacing assumptions, preferring the simplest sufficient solution, making surgical changes, and defining verifiable goals.

When should I use Karpathy Guidelines?

Karpathy Guidelines fits situations like: project configuration; purely factual questions; non-engineering tasks.

How do I install Karpathy Guidelines in Claude Code?

Run `npx skills add clabernetes/clabernetes --skill karpathy-guidelines -a claude-code`. Or copy the skill folder (.agents/skills/karpathy-guidelines in clabernetes/clabernetes) into .claude/skills/karpathy-guidelines in your project. Claude Code loads it when a task matches its description.

How do I install Karpathy Guidelines in Codex?

Run `npx skills add clabernetes/clabernetes --skill karpathy-guidelines -a codex`. Or copy the skill folder (.agents/skills/karpathy-guidelines in clabernetes/clabernetes) into .agents/skills/karpathy-guidelines in your project. Codex loads it when a task matches its description.

Can I use Karpathy Guidelines in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add clabernetes/clabernetes --skill karpathy-guidelines -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/karpathy-guidelines, .gemini/skills/karpathy-guidelines, .github/skills/karpathy-guidelines and .opencode/skills/karpathy-guidelines in your project.

What does Karpathy Guidelines need to run?

SKILL.md names no scripts, command-line tools or credentials: Karpathy Guidelines is instructions for the agent only.

Does Karpathy Guidelines access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Karpathy Guidelines safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Karpathy Guidelines use?

Karpathy Guidelines is published under the BSD-3-Clause licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Karpathy Guidelines use?

About 648 tokens (SKILL.md is roughly 2.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Karpathy Guidelines?

Skills that share tags, products or a category with Karpathy Guidelines: Guidelines (akash-network/node, 1.1k stars), Component Refactoring (langflow-ai/langflow, 155k stars), Migrate Core Code to Submodules (tinyhumansai/openhuman, 42k stars) and ast-grep Structural Search (code-yeongyu/oh-my-openagent, 70k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Karpathy Guidelines?

clabernetes (a GitHub organization) maintains it in clabernetes/clabernetes, which has 143 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 4, 2026.

Source: clabernetes/clabernetes on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.