karpathy-guidelines

Apply behavioral guidelines for minimal, precise code changes during development.

1|1|Updated Dec 20, 2025
One-click install
npx skills add https://github.com/orkestra-cc/orkestra --skill karpathy-guidelines-orkestra-cc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: karpathy-guidelines
Source: https://github.com/orkestra-cc/orkestra/tree/main/.claude/skills/andrej-karpathy-skills
Command: npx skills add https://github.com/orkestra-cc/orkestra --skill karpathy-guidelines-orkestra-cc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the common tendency for LLMs to overcomplicate code, make unverified assumptions, and perform unnecessary refactoring, which leads to bloated and fragile software.

Core Features & Use Cases

  • Behavioral Guardrails: Enforces a simplicity-first mindset to ensure code remains maintainable and minimal.
  • Surgical Change Protocol: Provides a framework for making precise edits that minimize regression risks.
  • Use Case: When tasked with adding a new feature, use these guidelines to ensure you only implement the requested functionality without adding speculative abstractions or over-engineering the solution.

Quick Start

Apply the karpathy-guidelines skill to review your proposed code changes and ensure they adhere to the simplicity and surgical change requirements.

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 and overcomplicated code generation?

To prevent LLM coding errors, apply behavioral guidelines that enforce a simplicity-first mindset, require explicit assumption surfacing, and mandate surgical editing to avoid speculative abstractions and unnecessary refactoring.

What is the best way to stop AI from over-engineering software during refactoring?

The best way to stop AI from over-engineering during refactoring is to use a surgical change protocol that ensures precise edits, minimizes regression risks, and restricts modifications strictly to requested functionality.

How do I enforce simplicity and precision for LLM code review tasks?

You can enforce simplicity and precision for LLM code review by applying behavioral guardrails that check for unverified assumptions, unnecessary complexity, and deviations from explicit goal-driven execution patterns.

Why does an LLM add speculative abstractions when adding a new feature?

An LLM adds speculative abstractions because it lacks inherent behavioral constraints. Applying goal-driven execution guidelines forces the model to surface explicit assumptions and implement only the requested functionality.

Can I use these coding heuristics for any software development task?

Yes, you can use these coding heuristics for any software development task involving code generation, review, and refactoring where simplicity and precision are critical to maintaining minimal, maintainable software.