8 Rules That Slash AI Coding Context From 280K to 35K Tokens: The Universal Token Efficiency Protocol v3.3.0

Executive Summary

After processing 60 billion tokens across AI coding agents, developer Marcos Hernanz distilled a surprisingly short 8-line rule set for AGENTS.md / CLAUDE.md files. The insight is uncomfortable for most teams: we've been filling our prompt context with the wrong things.

Tech stack details and directory trees — the stuff we dutifully dump into every agent config — are things an LLM can auto-discover in ~100ms using find or ls. What agents actually fail at is behavior, not knowledge. And behavior is exactly what a good rules file can shape.

💡 The Core Insight: Context Is Being Wasted on What Models Already Know

Open any team's CLAUDE.md or AGENTS.md and you'll find the same pattern: a wall of stack information, package versions, and directory maps. All of that is discoverable — an agent can run find . -maxdepth 2 -type d and reconstruct your layout in under a second.

What you can't discover from disk is how the model should behave. That's why Hernanz's rule set focuses almost entirely on behavioral anti-patterns — the recurring failure modes seen across 60B tokens of real agent output.

📋 The 8-Line Rule Set

The protocol ships an 8-pillar behavioral rule set for agent config files. Four of the pillars target the most damaging anti-patterns observed at scale:

Wrapped around those four are the protocol's complementary pillars — AST-first reading, dynamic output compression, context budgeting, and verification — which turn the rules into a repeatable system rather than a wishlist.

🚫 The Four Anti-Patterns Agents Actually Fail On

1. Skipping research and inventing custom schemas

The agent opens a task, doesn't look at how the codebase models data, and invents a schema that matches nothing. The fix is a rule that forces discovery before implementation — read the existing types, use the existing conventions.

2. Creating complex indirect abstractions when a simple function works

Instead of a 10-line function, the agent generates a factory, an interface, and three indirection layers. The rule: the simplest solution that fits the codebase's style wins.

3. Re-writing existing helper utilities instead of auditing dependencies

The repo already has format_date(), but the agent writes a new one with a subtly different behavior. The rule: audit before you write — a 30-second grep saves a 300-line re-implementation.

4. Replacing working code with broken, unfinished complexity

The most expensive failure of all: a working module is replaced with a half-finished abstraction that doesn't run. The rule: working code is the baseline — never trade it for speculative refactors.

⚙️ How the Protocol Enforces the Rules

Rules only work if the harness enforces them cheaply. The Universal Token Efficiency Protocol pairs the 8 pillars with two mechanical layers:

🔍 AST-First Reads (grep ➔ sed -n)

Instead of dumping whole files into context, the protocol reads structure-first: grep for symbols, then sed -n to pull only the exact line ranges that matter. Context is loaded lazily and surgically.

# Old way: read the whole file into context
cat src/service.py

# Protocol: discover, then read only what matters
grep -n "def \|class " src/service.py
sed -n '12,40p' src/service.py   # only the function you need

🧮 Dynamic Tool Output Compression (DTOC)

Tool output — search results, logs, directory listings — is compressed in-flight before it ever enters the context window. Headers, repeated patterns, and low-signal lines are collapsed; the agent gets the semantic content at a fraction of the token cost.

An 8× reduction in context load — from ~280K to ~35K tokens per task — while model pass rates match top frontier models at a fraction of the cost.

🚀 Using It in Your Stack

The protocol is open source and ships with the full spec plus 11+ IDE adapters — drop the rules into your existing AGENTS.md / CLAUDE.md whether you're on Claude Code, Cursor, or any agentic coding tool.

# AGENTS.md / CLAUDE.md — core behavioral section (condensed)
# 1. Research before you build — discover schemas, don't invent them
# 2. Prefer simple functions over indirect abstractions
# 3. Audit existing dependencies before re-writing helpers
# 4. Never replace working code with broken, unfinished complexity
# 5. Read AST-first: grep, then sed -n the exact lines
# 6. Compress tool output before it enters context
# 7. Keep the context budget small — spend it on behavior
# 8. Verify before declaring done

📦 Resources

• Full protocol spec, 11+ IDE adapters, and interactive WebGL benchmark demo: github.com/romangalaxys10-spec/token-efficiency-skill
• 10% OFF Z.AI GLM Coding Plan Invite Token: z.ai/subscribe — code R0K78RJKNW

🎯 The Bottom Line

The numbers are the story. An 8× context reduction without sacrificing pass rates changes the economics of agentic coding — fewer tokens per task means lower cost, longer agent runs, and more headroom for the work that actually matters.

Whether you're a solo developer on Claude Code, a team standardizing on Cursor, or an enterprise rolling out agentic workflows across the US, EU, or APAC, the protocol is free to adopt: copy the rules into your agent config, switch to AST-first reads, and let DTOC handle the output.