andrej-karpathy-skills

Guide coding agents to apply small, goal-aligned changes with verifiable checks.

130|14|Updated Apr 30, 2026
One-click install
npx skills add https://github.com/dmae97/oh-my-kimi --skill andrej-karpathy-skills
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: andrej-karpathy-skills
Source: https://github.com/dmae97/oh-my-kimi/tree/main/templates/skills/agents/andrej-karpathy-skills
Command: npx skills add https://github.com/dmae97/oh-my-kimi --skill andrej-karpathy-skills

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the problem of unreliable coding outcomes by enforcing a disciplined, goal-driven workflow that minimizes regressions and proves success with observable checks.

Core Features & Use Cases

  • Assumption clarification: surfaces only the assumptions that materially affect implementation, asking for clarification when ambiguity blocks safe progress.
  • Evidence-based success criteria: converts “do the change” requests into verifiable outcomes such as tests, lint, typecheck, build, screenshots, or exact output.
  • Smallest-scope execution: limits file touchpoints and avoids unrelated cleanup so refactors, bugfixes, and debugging remain tightly bounded.

Quick Start

Use this skill when you want an AI to implement a refactor or bugfix with a minimal diff and clear success checks for the changed behavior.

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 regressions when using an AI coding agent for refactoring?

Prevent regressions during refactoring by enforcing a structured workflow that limits file modifications to the smallest scope and requires verifiable success checks like tests, typecheck, or build output to prove behavior remains intact.

What is the best way to ensure AI code changes are safe and verifiable?

Safe and verifiable code changes are achieved by converting requests into evidence-based success criteria, demanding observable pass/fail results from lint or build commands, and constraining edits to avoid unrelated cleanup that could break existing behavior.

How do I manage ambiguity in bugfixing tasks without causing broad code edits?

Manage ambiguity in bugfixing by surfacing only materially impactful assumptions and asking for clarification when ambiguity blocks safe progress, ensuring the coding agent executes constrained, targeted edits rather than broad, speculative code changes.

Does this approach work for debugging tasks that require strict output validation?

Yes, debugging tasks work with this approach by applying a structured output contract that records changed files, commands run, exact pass/fail results, and remaining risks, ensuring strict validation through observable evidence and measurable success.

When should I avoid using an automated refactoring workflow for code changes?

Avoid using automated refactoring workflows when a task requires large-scale architectural rewrites or unrelated cleanup, as this approach prioritizes minimal diffs and tightly bounded file modifications to strictly reduce regression risk.