In partnership with

Hey {{first_name | there}},

120,000 developers starred a 65-line text file in 2026.

Not a new model. Not a framework. Not a SaaS tool.
A single markdown file sitting quietly at the root of a GitHub repo.

And the reason it went viral? It cut Claude's mistake rate from 41% to 11%.

Here’s why it matters even if you're not a developer, and the full 12 rules you can use starting today.

It Started With a Complaint

In January 2026, Andrej Karpathy (former Tesla AI director, OpenAI co-founder) posted a thread about Claude's coding behavior. Three very specific frustrations:

  1. Claude makes silent wrong assumptions instead of asking

  2. Claude overcomplicates things nobody asked it to complicate

  3. Claude touches adjacent code it was never supposed to touch

A developer named Forrest Chang read that thread, packaged those three complaints into 4 behavioral rules inside a CLAUDE.md file, and pushed it to GitHub:

The fastest-growing single-file repo of 2026.

In case you don’t know what CLAUDE.md is:

It's a file you drop at the root of your project folder. Claude Code reads it automatically before every session. Think of it as a behavioral contract, not a wish list.

Anthropic's own docs say Claude follows it about 80% of the time. Past 200 lines, compliance drops sharply because rules get buried in noise:

So the goal is to keep it tight, focused, and ruthlessly specific.

The Original 4 Rules 

Forrest's 4 rules closed roughly 40% of failure modes developers were seeing.

Rule 1 - Think Before Coding

State assumptions explicitly. Ask rather than guess. Push back when a simpler approach exists. Stop when confused and name what's unclear.

Rule 2 - Simplicity First

Minimum code that solves the problem. No speculative features. No abstractions for single-use code. If a senior engineer would call it overcomplicated, simplify.

Rule 3 - Surgical Changes

Touch only what you must. Don't improve adjacent code, comments, or formatting. Don't refactor what isn't broken.

Rule 4 - Goal-Driven Execution

Define success criteria. Loop until verified. Don't tell Claude what steps to follow. Tell it what success looks like.

These four rules were built for January 2026's problem: Claude-as-autocomplete.

But by May 2026, the problem had evolved into something different. Multi-step agents, session-spanning workflows, 12-service monorepos.

The 4 rules didn't address any of that.

The 8 Rules That Closed the Remaining Gap

Rule 5 - Use Claude only for judgment calls

Use it for classification, summarization, drafting. Don't use it to decide whether to retry an API call or how to route a message. If a status code already answers the question, plain code answers it.

Rule 6 - Token budgets are not advisory

Set a per-task budget of 4,000 tokens and a per-session budget of 30,000 tokens.

If a task approaches the limit, summarize and start fresh. The moment you leave this open-ended, Claude will iterate on the same problem for 90 minutes, suggesting fixes it already tried 40 messages ago.

Rule 7 - Surface conflicts, don't average them

If two patterns in your codebase contradict, pick one (the more recent, more tested option) and flag the other for cleanup.

Claude's default is to blend them. Averaged code satisfies both patterns and solves neither.

Rule 8 - Read before you write

Before adding code to a file, Claude must read the file's exports, immediate callers, and shared utilities.

Rule 3 tells it not to touch adjacent code. Rule 8 tells it to understand adjacent code first.

These are not the same thing.

Rule 9 - Tests verify intent, not just behavior

Every test must encode WHY the behavior matters, not just WHAT it does. A test that can't fail when business logic changes isn't a test. It's theater.

Rule 10 - Checkpoint after every significant step

In multi-step tasks, summarize what was done, what's verified, and what's left before moving on.

Rule 11 - Match the codebase's conventions, even if you disagree

If the codebase uses snake_case, use snake_case. If disagreement exists about a convention, surface it. Don't fork it silently.

Convention > taste, inside the codebase.

Rule 12 - Fail loud

"Migration completed" is wrong if 30 records were skipped.
"Tests pass" is wrong if any were skipped.
"Feature works" is wrong if the edge case wasn't verified.

Default to surfacing uncertainty.

How to Install

Two steps:

1. Append Karpathy's 4-rule baseline to your CLAUDE.md

curl https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md >> CLAUDE.md

2. Paste rules 5-12 from this newsletter 

Save at your repo root. The >> matters, it appends to your existing CLAUDE.md instead of overwriting any project-specific rules you already have.

You can grab the full copy-paste ready 12-rule file here.

One Rule About All of These Rules

Don't paste all 12 blindly.

Read them, keep the ones that match mistakes you've actually made, drop the rest.

A 6-rule CLAUDE.md tuned to your real failure modes beats a 12-rule one with 6 rules you'll never need.

This is, by the way, not just for developers.

If you use Claude for writing, research, or agent-driven workflows, the underlying failure modes are identical.

Silent assumptions. Over-complication. Adjacent damage. Tests that test nothing.

The domain changes. The behavior doesn't.

And whatever you do, stay under 200 lines.

Try it and reply back with what changed. I'm genuinely curious which rule fixes the most for you.

— Aashish

What did you think about today's newsletter?

Login or Subscribe to participate

The Architecture Behind AI-Native Revenue Automation

In our new white paper, The Architecture Behind AI-Native Revenue Automation, Tabs CTO Deepak Bapat breaks down what it actually takes to apply AI to revenue workflows without breaking the books.

You’ll learn why probabilistic reasoning isn’t enough for finance, how Tabs pairs LLMs with deterministic logic, and why a unified Commercial Graph is the foundation for scalable, audit-ready automation. From contract interpretation to cash application, this paper goes deep on where AI belongs—and where it absolutely doesn’t.

If you’re evaluating AI for billing, collections, or revenue operations, this is the architecture perspective most vendors won’t show you.

Reply

Avatar

or to participate

Keep Reading