karpathy-guidelines

Outline behavioral guidelines for writing, reviewing, and refactoring code.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/ty91/claude-code-configs --skill karpathy-guidelines-ty91
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: karpathy-guidelines
Source: https://github.com/ty91/claude-code-configs/tree/main/skills/karpathy-guidelines
Command: npx skills add https://github.com/ty91/claude-code-configs --skill karpathy-guidelines-ty91

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the common and costly tendency to overlook assumptions, skip explicit tradeoffs, and apply poorly scoped changes during coding tasks. It provides a concise, repeatable framework to guide writing, reviewing, and refactoring so teams can avoid overcomplication and surface verifiable success criteria. Key concepts include surfacing assumptions, identifying tradeoffs, and enforcing minimal, surgical changes.

Core Features & Use Cases

  • Explicit assumptions are surfaced at the start of each task.
  • Tradeoffs are surfaced and weighed to choose the simplest viable solution.
  • Surgical changes: edits touch only what is necessary and preserve existing structure.
  • Use it during task planning, code reviews, and refactoring to maintain clarity and verifiability.
  • Example: when starting a new feature, outline assumptions, constraints, and success criteria before writing code.

Quick Start

  • List assumptions explicitly.
  • State the tradeoffs and select the simplest viable approach.
  • Define verifiable success criteria and a brief plan of measurable steps.
  • Apply surgical changes and document exact edits.
  • Use during reviews to keep changes focused and justified.

Frequently Asked Questions about karpathy-guidelines

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

FAQPage Schema
How do I surface coding assumptions and tradeoffs before writing new features?

Surface coding assumptions by explicitly listing them at the start of each task. State the tradeoffs to select the simplest viable approach, and define verifiable success criteria before applying surgical changes to preserve existing structure.

What are surgical changes in code review and refactoring?

Surgical changes are minimal, focused edits that touch only what is necessary during code review and refactoring. This approach preserves existing structure, prevents overcomplication, and ensures modifications remain justified and verifiable.

How do I establish verifiable success criteria for refactoring tasks?

Establish verifiable success criteria for refactoring by defining a brief plan of measurable steps. Outline assumptions and constraints beforehand, then apply surgical changes to ensure the refactoring results remain measurable and focused.

Does this coding guidelines framework work for both individual developers and teams?

This coding guidelines framework works for both individual developers and teams across software projects. It enforces explicit assumptions, surfaces tradeoffs, and defines verifiable success criteria during task planning, code reviews, and refactoring sessions.

Why should I outline assumptions and constraints before writing code?

Outline assumptions and constraints before writing code to avoid the costly tendency to overlook implicit tradeoffs and apply poorly scoped changes. This framework enforces minimal, surgical changes to prevent overcomplication and maintain clarity.

How do I keep code changes focused and justified during reviews?

Keep code changes focused and justified during reviews by enforcing explicit assumptions and minimal, surgical changes. Surface tradeoffs to choose the simplest viable solution, ensuring all edits are documented and verifiable against success criteria.