karpathy-guidelines

Enforce defensive coding behaviors during implementation and refactoring.

2|Updated Apr 8, 2026
One-click install
npx skills add https://github.com/miptah21/skills --skill karpathy-guidelines-miptah21
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: karpathy-guidelines
Source: https://github.com/miptah21/skills/tree/main/.agents/skills/karpathy-guidelines
Command: npx skills add https://github.com/miptah21/skills --skill karpathy-guidelines-miptah21

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill reduces common LLM coding failures by enforcing defensive practices that prevent speculative complexity, minimize unnecessary diffs, and make outcomes verifiable through explicit success criteria.

Core Features & Use Cases

  • Clarify before implementing: Surface assumptions, ask questions when ambiguous, and present tradeoffs when multiple interpretations exist.
  • Simplicity-first implementation: Prefer minimal code that solves the requested problem without future-proofing or unnecessary abstractions.
  • Surgical edits only: Modify only what the user requested, avoid changing adjacent code, and remove only orphaned code introduced by your changes.
  • Goal-driven verification loop: Convert vague tasks into verifiable targets and iterate with a plan-act-verify structure until checks pass.

Use it when generating, reviewing, or refactoring code to ensure the result is maintainable, targeted, and testable rather than over-engineered.

Quick Start

Use the karpathy-guidelines skill when you need to implement or refactor a feature and want the AI to ask clarifying questions first, keep the diff surgical, and define concrete success checks before finalizing code.

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 mistakes during refactoring?

Reduce LLM coding mistakes by enforcing defensive practices like clarifying ambiguous requests upfront, making surgical edits to avoid unnecessary diffs, and verifying results against explicit success criteria before finalizing.

What is the best way to keep code maintainable when using AI for implementation?

Keep AI-generated code maintainable by enforcing simplicity-first implementation, avoiding speculative abstractions and future-proofing, and ensuring surgical edits that modify only requested code without altering adjacent structures.

How do I create a goal-driven verification loop for ambiguous feature requests?

Create a goal-driven verification loop by converting vague feature requests into verifiable targets, then iterating through a plan-act-verify structure until explicit success criteria checks pass.

Why does AI generate over-engineered code and unnecessary abstractions?

AI generates over-engineered code due to speculative complexity, which defensive programming prevents by enforcing simplicity-first changes that solve only the requested problem without future-proofing or unnecessary abstractions.

When should I ask clarifying questions before implementing code changes?

Ask clarifying questions when feature requests are ambiguous, multiple interpretations exist, or tradeoffs need presentation, ensuring assumptions are surfaced before starting simplicity-first implementation and surgical edits.