karpathy-guidelines

Enforce Karpathy-aligned coding discipline with a four-step workflow.

1|1|Updated Apr 10, 2026
One-click install
npx skills add https://github.com/magicpro97/copilot-session-knowledge --skill karpathy-guidelines-magicpro97
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: karpathy-guidelines
Source: https://github.com/magicpro97/copilot-session-knowledge/tree/main/skills/karpathy-guidelines
Command: npx skills add https://github.com/magicpro97/copilot-session-knowledge --skill karpathy-guidelines-magicpro97

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Behavioral guidelines to reduce common LLM coding mistakes, surface assumptions, and promote minimal, verifiable changes when writing, reviewing, or refactoring code.

Core Features & Use Cases

  • Think Before Coding: Explicitly state assumptions, surface tradeoffs, and ask questions when unclear to avoid silent misinterpretations.
  • Simplicity First: Prioritize the minimal, well-scoped solution with no unnecessary abstractions or features.
  • Surgical Changes: Edit only what is necessary, avoid touching unrelated code, and report any collateral impact.
  • Goal-Driven Execution: Convert tasks into measurable goals with clear success criteria and an explicit plan when handling multi-step work.

Quick Start

State assumptions explicitly, propose a minimal, plan-driven approach, and implement only the changes required to satisfy the objective.

Frequently Asked Questions about karpathy-guidelines

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

FAQPage Schema
How do I enforce minimal, surgical changes when using LLMs for code refactoring?

To enforce surgical changes during code refactoring, apply a four-step plan-driven workflow that explicitly states assumptions, scopes tasks minimally, and edits only necessary code to avoid collateral impact. This reduces common LLM overcomplication.

What is the best way to surface hidden assumptions before writing code with an LLM?

Surfacing hidden assumptions before writing code requires explicitly stating all expectations and tradeoffs upfront, asking clarifying questions when unclear, and converting tasks into measurable goals with clear success criteria to prevent silent misinterpretations.

How do I keep LLM-generated code simple and avoid unnecessary abstractions?

Keeping LLM-generated code simple requires prioritizing well-scoped solutions with no unnecessary abstractions, ensuring tasks remain verifiable and minimal, and applying surgical edits that touch only the code necessary to satisfy the objective.

Does plan-driven coding help with multi-step refactoring tasks?

Plan-driven coding helps multi-step refactoring by converting tasks into measurable goals with clear success criteria and an explicit plan, ensuring execution remains scoped, verifiable, and minimal throughout the entire process.

Why does LLM coding often result in overcomplicated solutions and unrelated code changes?

LLM coding often results in overcomplicated solutions due to silent misinterpretations and unscoped execution. Applying coding discipline that prioritizes simplicity, explicitly surfaces assumptions, and restricts edits to surgical changes prevents these missteps.

When should I not use an autonomous approach for code refactoring?

You should not use an autonomous approach for code refactoring when tasks lack clear success criteria, have unstated assumptions, or require multi-step execution, as unscoped changes risk collateral impact and unnecessary abstractions.