andrej-karpathy-skills

Enforce cautious assumptions, minimal implementations, and precise code changes in AI coding workflows.

Updated May 17, 2026
One-click install
npx skills add https://github.com/tiankong0101-byte/skills-registry --skill andrej-karpathy-skills-tiankong0101-byte
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: andrej-karpathy-skills
Source: https://github.com/tiankong0101-byte/skills-registry/tree/main/skills/andrej-karpathy-skills
Command: npx skills add https://github.com/tiankong0101-byte/skills-registry --skill andrej-karpathy-skills-tiankong0101-byte

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps AI coding assistants avoid common mistakes by applying Andrej Karpathy-inspired programming guidelines that favor clarity, simplicity, and careful execution.

Core Features & Use Cases

  • Think before coding: Surfaces assumptions, ambiguity, and tradeoffs before implementation.
  • Simplicity first: Keeps changes minimal and avoids speculative features or overengineering.
  • Surgical edits: Limits modifications to what is directly required and cleans up only what it creates.
  • Goal-driven execution: Encourages explicit success criteria and verification steps for multi-step tasks.
  • Use case: Ideal when drafting project instructions, reviewing code changes, or guiding an AI agent through a small but sensitive coding task.

Quick Start

Ask the AI to follow the Karpathy-style guidelines while solving your coding task and to state assumptions, keep changes minimal, and verify the result.

Frequently Asked Questions about andrej-karpathy-skills

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

FAQPage Schema
How do I prevent AI coding assistants from overengineering and making unnecessary code changes?

To prevent AI overengineering, apply coding guidelines that enforce cautious assumptions and minimal implementations. This approach limits modifications to surgical edits, ensuring changes remain strictly goal-oriented and avoid speculative features.

What are the best coding guidelines for LLM-assisted refactoring and bug fixes?

Effective LLM-assisted refactoring guidelines prioritize simplicity, clear tradeoff analysis, and verification-driven execution. They require the AI to state assumptions upfront and perform surgical edits, directly addressing the task without introducing unnecessary modifications.

How do I enforce clear tradeoff analysis before an AI agent implements code changes?

You can enforce clear tradeoff analysis by instructing the AI to follow coding discipline that surfaces assumptions and ambiguity before implementation. This ensures the agent thinks through tradeoffs and establishes explicit success criteria prior to coding.

Can I use these coding guidelines for sensitive software engineering tasks like instruction merging?

Yes, these coding guidelines are ideal for sensitive software engineering tasks including instruction merging and refactoring. They satisfy verification-driven execution by encouraging explicit success criteria and surgical edit discipline for precise code changes.

What is surgical edit discipline in LLM-assisted development workflows?

Surgical edit discipline in LLM-assisted development limits modifications to exactly what a task requires. It prevents speculative features by ensuring the AI cleans up only what it creates, maintaining simplicity and precise code changes.