karpathy-principles

Inject a discipline layer to surface assumptions and minimize scope creep in software changes.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Injectable discipline that surfaces assumptions, enforces simplicity, and guides surgical changes to avoid scope creep and unclear goals.

Core Features & Use Cases

  • Injects a discipline layer into planning, coding, and review stages to surface risk and clarity.
  • Encourages small, verifiable changes with explicit acceptance criteria and governance anchors.
  • Useful during M1 tasks, refactors, or planning sessions where ambiguity could lead to large blast-radius changes.

Quick Start

Invoke the karpathy-principles skill to surface assumptions and craft minimal, verifiable changes.

Frequently Asked Questions about karpathy-principles

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

FAQPage Schema
How do I prevent scope creep during software refactoring and planning tasks?

Preventing scope creep during refactoring requires injecting a discipline layer before code changes to surface assumptions and enforce surgical, verifiable modifications. This approach minimizes blast radius by guiding developers through explicit thinking during planning, coding, and reviewing tasks.

What is the best way to surface hidden assumptions before making ambiguous code changes?

Surfacing hidden assumptions before ambiguous code changes involves applying governance anchors and falsifiable triggers during planning. This process enforces explicit thinking, ensuring small changes have clear acceptance criteria and minimizing risk in tasks with large blast radius.

Can I use engineering principles to enforce discipline during code review?

Engineering principles can enforce discipline during code review by integrating a governance layer that checks for simplicity and explicit acceptance criteria. This ensures reviewers verify surgical changes and confirm that scope creep and unclear goals were avoided during the coding phase.

Does applying a discipline layer to software changes slow down the development process?

Applying a discipline layer does not slow development but rather focuses it by minimizing scope creep and reducing blast radius. By surfacing assumptions early during planning and refactoring, it prevents costly errors and ensures small, verifiable, and safe software changes.

When do I need explicit governance anchors for my software engineering workflow?

You need explicit governance anchors when facing M1 tasks, refactors, or planning sessions where ambiguity could lead to large blast-radius changes. These anchors enforce simplicity and guide surgical code modifications by surfacing risks early in the workflow.