danieldekay/ai-ops/context-efficiency

Context Efficiency

Three rules. Follow all three at all times.

Why this matters: In a typical 2-hour coding session, an agent runs ~60 shell commands

averaging 3,500 tokens of output each — 210,000 tokens of CLI noise alone, nearly filling a

200K window before reasoning even begins. RTK users report sessions lasting ~3× longer before

hitting the context wall. (Source: rushis.com, 2025)

Rule 1: Always prefix CLI commands with rtk

rtk is installed at ~/.local/bin/rtk. It intercepts stdout and compresses it before the context window ever sees it. Savings range from 60% to 99%.

Every terminal command gets the prefix. No exceptions.

# ❌ Never
git diff HEAD~1
find . -name "*.py"
pytest -v
grep -r "pattern" src/
 
# ✅ Always
rtk git diff HEAD~1
rtk find . -name "*.py"
rtk pytest
rtk grep "pattern" src/

This applies in && chains too:

rtk git add . && rtk git commit -m "msg" && rtk git push

High-impact commands

One-time setup (preferred)

rtk init -g       # installs global hook — no prefix needed after this, rtk applies automatically

If the global hook is not installed, fall back to explicit prefix on every command. Check cumulative savings at any time: rtk gain

If a project has no .rtk/ config: rtk init creates CLAUDE.md + .rtk/filters.toml.

Rule 2: Offload memory — never hold large content in context

Just-in-time retrieval beats upfront loading. Only bring information into context when you actively need it for the current step.

Threshold strategy (from Anthropic context engineering guidance)

External memory: use MCPs for persistence

Route persistent data to external stores rather than keeping it inline in context.

Narrow reads

Use search tools (grep_search, semantic_search) before read_file. Specify exact line ranges. Never load a file to "see what's in it" — search first, read only the relevant section.

Rule 3: Keep context lean — avoid context pollution

Context pollution (too many tools, too much irrelevant history, redundant data) degrades reasoning quality even when the window has space. Active hygiene rules:

• Don't front-load. Don't dump files, docs, or search results into context unless you need

them for the current step. Retrieve dynamically.

• Summarize, don't accumulate. After completing a sub-task, reduce what stays in context to

a 1–2 sentence outcome. Drop the intermediate steps.

• Sub-agents for heavy exploration. When a task requires deep file reading or many tool

calls, delegate to a sub-agent. It can burn 50K+ tokens internally but returns only a distilled 1–2K token summary to the main context. (Anthropic research: sub-agents achieve 90% performance improvement despite using 15× more tokens overall.)

• Tool minimalism. Each unused tool in scope is dead weight. Load skills and context only

when they are relevant to the current task.

What this skill does NOT cover

Writing quality, skill selection, test strategies — those are separate skills. This skill is only about not wasting context on CLI noise, redundant reads, and pollution.