karpathy-guidelines

Guide LLM coding with upfront thinking, simplicity, and surgical edits.

8|1|Updated Feb 16, 2026
One-click install
npx skills add https://github.com/caidanw/skills --skill karpathy-guidelines-caidanw
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: karpathy-guidelines
Source: https://github.com/caidanw/skills/tree/main/karpathy-guidelines
Command: npx skills add https://github.com/caidanw/skills --skill karpathy-guidelines-caidanw

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps prevent common coding errors made by Large Language Models by providing a set of behavioral guidelines focused on clarity, simplicity, and verification.

Core Features & Use Cases

  • Pre-coding Clarity: Ensures assumptions are surfaced and tradeoffs are considered before implementation.
  • Simplicity Enforcement: Guides towards minimal, non-speculative code.
  • Surgical Editing: Promotes focused changes, touching only what's necessary.
  • Goal-Oriented Development: Emphasizes defining verifiable success criteria for tasks.
  • Use Case: When an LLM is asked to refactor a piece of code, these guidelines ensure it only modifies the necessary parts and doesn't introduce speculative features.

Quick Start

Apply the karpathy-guidelines skill to ensure the LLM writes simple, surgical, and goal-driven code.

Frequently Asked Questions about karpathy-guidelines

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent LLM coding errors during refactoring?

Prevent LLM coding errors during refactoring by applying behavioral guidelines that enforce surgical modifications, ensuring the model touches only necessary lines and avoids introducing speculative features.

What are the best practices for LLM code generation simplicity?

Best practices for LLM code generation simplicity involve surfacing assumptions upfront, writing minimal non-speculative code, and defining verifiable success criteria to maintain goal-driven execution.

How do I ensure LLM code quality when writing new features?

Ensure LLM code quality by establishing pre-coding clarity where tradeoffs are considered and assumptions are surfaced before implementation, enforcing simplicity and goal-oriented development.

Does this approach work for general code review and refactoring?

Yes, these coding guidelines are applicable during code writing, review, and refactoring phases to enhance overall code quality and reduce overcomplication across the development lifecycle.

Why does an LLM overcomplicate simple code modifications?

An LLM overcomplicates simple code modifications when lacking upfront thinking and surgical editing constraints, leading to speculative features rather than focused, minimal changes to necessary lines.

What is the best way to define verifiable success criteria for LLM tasks?

Define verifiable success criteria for LLM tasks by establishing goal-oriented development parameters upfront, ensuring the generated code meets specific, testable outcomes without unnecessary modifications.