agentic-karpathy

Enforce surgical code changes and verification before and during implementation.

3|Updated Apr 10, 2026
One-click install
npx skills add https://github.com/alphabeen/oh-my-jinho --skill agentic-karpathy-alphabeen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agentic-karpathy
Source: https://github.com/alphabeen/oh-my-jinho/tree/main/skills/agentic-karpathy
Command: npx skills add https://github.com/alphabeen/oh-my-jinho --skill agentic-karpathy-alphabeen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Behavioral guardrails to prevent common LLM coding mistakes by enforcing surgical changes, assumption verification, and scope discipline before and during implementation.

Core Features & Use Cases

  • Hard Gates: enforce reading before writing, define success, and restrict changes to the scope.
  • Rule-based discipline: Five Rules, surgical changes, and strict verification.
  • When To Use: before implementing features, during code reviews, or code modification tasks.

Quick Start

Before coding, read the existing code, define success, and make only surgical changes.

Frequently Asked Questions about agentic-karpathy

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

FAQPage Schema
How do I prevent LLM coding mistakes during code modification?

To prevent LLM coding mistakes, enforce behavioral guardrails like reading existing code before writing, defining success criteria, and making surgical changes scoped to the request. This ensures modifications remain controlled.

What are hard gates in code review for AI agents?

Hard gates in code review are strict rules enforcing read-before-write, success definition, and scope restriction. They prevent unverified assumptions and ensure modifications are surgical and limited to the requested changes.

How to enforce scope discipline when using LLMs for software engineering?

Enforce scope discipline by applying behavioral guardrails that restrict changes to the explicit request, verify assumptions, and mandate reading code before writing. This limits modifications to surgical, necessary updates.

Does applying read-before-write rules improve code writing safety?

Applying read-before-write rules improves code writing safety by forcing verification of existing code and assumptions before implementation. This prevents unintended side effects and limits changes to surgical modifications.

When should I use surgical change guardrails for code generation?

Use surgical change guardrails before implementing features, during code reviews, and when modifying code. They enforce reading before writing, verify assumptions, and restrict scope to prevent common LLM coding mistakes.