karpathy-guidelines

Enforce minimal, verifiable code changes with explicit assumptions and tradeoffs.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you avoid common LLM coding mistakes such as overengineering, unclear assumptions, and unnecessary refactoring by encouraging deliberate, minimal, and verifiable changes.

Core Features & Use Cases

  • Think Before Coding: Surface assumptions, ambiguity, and tradeoffs before making changes.
  • Simplicity First: Prefer the smallest solution that solves the request without speculative features.
  • Surgical Changes: Modify only what is necessary and avoid unrelated cleanup.
  • Goal-Driven Execution: Define success criteria and verify progress with tests or checks.
  • Use Case: Review a code change request, identify hidden assumptions, and produce a focused implementation plan with clear validation steps.

Quick Start

Ask for a concise, minimally invasive code change plan that explicitly states assumptions, scope, and how the result will be verified.

Frequently Asked Questions about karpathy-guidelines

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

FAQPage Schema
How do I prevent unnecessary refactoring and overcomplication in code review?

To prevent unnecessary refactoring in code review, enforce surgical modifications that change only what is necessary. Define explicit tradeoffs and state assumptions upfront to avoid speculative features and ambiguous edits.

What is the best way to write minimal code changes with verifiable outcomes?

Writing minimal code changes with verifiable outcomes requires defining success criteria before implementation. Prefer the smallest solution that solves the request, then verify progress using tests or checks.

How do I surface hidden assumptions before making coding changes?

Surfacing hidden assumptions before coding changes requires deliberate planning. Identify ambiguity and tradeoffs explicitly, then produce a focused implementation plan that minimizes risk before writing any code.

Does enforcing coding guidelines work for both new code writing and refactoring tasks?

Enforcing coding guidelines works for both new code writing and refactoring tasks. It applies careful assumptions, minimal implementations, and testable success criteria to ensure reliable software changes across both scenarios.

Why does my code review introduce risk through unrelated cleanup edits?

Code review introduces risk through unrelated cleanup edits when changes are not surgical. To reduce coding errors, modify only what is necessary and avoid unrelated cleanup that can introduce unexpected complications.

When should I not use minimal implementations for software changes?

You should not use minimal implementations when a request requires speculative features or unrelated cleanup. If the task demands broad architectural changes, surgical modifications may be insufficient for the required scope.