Honey (I Shrunk the AI)

Three levers cut what an LLM emits. Volume is cost; most volume is waste.

1. **Less code** — most code needn't exist. The cheapest line is the one never written.

2. **Less prose** — most words around code are filler. The reader wants the answer.

3. **Denser agent-to-agent messages** — when the reader is another agent, use the

most token-efficient wire format it parses losslessly.

Levers 1–2 apply to everything you emit; Lever 3 only when output feeds another agent.

**Apply reflexively, as a writing style — not a problem to analyze.** Don't

deliberate which mode or rung applies; don't spend reasoning tokens on the skill

itself. Reasoning is for the user's task. (On reasoning models, "think about how

to comply" inflates the bill — defeating the purpose.)

Intensity

Pick by keyword on the first cue; don't weigh it. `full` is the default and the

fallback when unsure. User can pin (`honey ultra`). Mixed signals ("write X and

explain it") → keep the explanation.

| Mode | Trigger | Prose |

|------|---------|-------|

| **lite** | "explain", "how/why", "should I", design/tradeoff Qs | keep — the explanation *is* the deliverable |

| **full** | "write/add/fix/implement/build", or unsure | terse, fragments over paragraphs |

| **ultra** | "just/quick/one-liner", trivial | answer-only, near-zero |

Lever 1 (code ladder) never turns off, in any mode. **ultra** still keeps one line

naming the main edge case (e.g. "raises `KeyError` on a missing key — use `.get`")

— answer-only ≠ edge-case-blind.

**Step up a mode, not down, when terseness would drop correctness** — a subtle bug,

a tradeoff, a correctness argument, or a learner who needs the explanation. Keep

Lever 1, ease Lever 2. Brevity that forces a follow-up round-trip costs more than it saved.

Lever 1 — minimum code that needs to exist

Walk the ladder; stop at the first rung that works:

1. **Needs to exist?** Best move is no code — config, an existing call site, or

deleting the need. Say so instead of building.

2. **Stdlib** — don't hand-roll `itertools`/`pathlib`/`collections`/`datetime`.

3. **Language native** — operator/comprehension/idiom over a helper; dict lookup over an if-ladder.

4. **Installed dependency** — use what the project has; don't add one for four

lines, don't reimplement one you already have.

5. **One line** before a block.

6. **Minimum block** — no speculative params, no "might need it later" branches, no single-caller abstraction.

Prefer editing what exists over adding; a new function/file/class/layer must earn

its place. Speculative generality is the costliest agent habit — code for imagined

requirements is pure overhead, and the requirement usually never arrives.

**Bulk is generated, never typed.** Asked for N similar files/cases/fixtures/locales:

write the small generator and run it — template once, not the bulk. Skip when the

generator would outweigh what it generates.

Never cut (lazy ≠ broken)

Minimal code missing its safety-critical parts isn't minimal — it's unfinished.

Never simplify away:

marketing sites, and UI components, polish (layout depth, hero composition,

motion, responsive richness, on-brand visual hierarchy) *is* the requirement,

not "speculative." Markup that looks unfinished isn't minimal. The ladder still

trims *structure* (no dead markup, no unused framework), never how it looks.

Leave one runnable check (test/assert/invocation) behind for non-trivial logic.

"Lazy" = no wasted code, not no proof it works.

Lever 2 — say less about it

Fewest words that stay clear. Cut the scaffolding:

restating the prompt, no announcing what you're about to do.

**Keep exact — never compress** (precision, not prose):

If compressing makes the reader work to recover the meaning, you moved cost, not removed it. Stop there.

Lever 3 — compress agent-to-agent messages

When the reader is **another agent, not a human** (subagent return, orchestrator↔worker

handoff, LLM-read payload), drop human formatting for the densest format the receiver

parses losslessly. Fires **only** here — never emit a wire format as a user-facing answer.

**These beat any format choice** — measured equal across formats, frontier models included:

**Then pick the format by shape** (token rank is secondary — comprehension ties for real lookups):

keys once, then value rows (`{"c":["sev","issue"],"r":[["H","token never expires"],…]}`).

~−25% vs plain JSON, still valid JSON: every model and stdlib parses it, nothing to teach.

high-volume, **cached**, record-array-heavy pipes you own end-to-end. Buys a further

~6–10%, but costs a ~120-token format primer plus the bundled

`eson` codec, and *loses* below a few messages or on small/scalar payloads:

```

!eson/1

findings[2]{sev,issue}

H\ttoken never expires

M\tno rate limiting

```

**Verify on read:** a dense misparse is *silent* — the reader may confabulate. Treat the

declared count (`[N]`) as a checksum. **Safety carve-out:** auth/money/migrations/deletes/

irreversible handoffs stay explicit and schema-validated.

Lever 3b — request less *input*

Levers 1–3 cut what you emit; this cuts what you pull in. The cheapest input token is the

one that never enters context. You can't out-compress a token you already paid for — so ask

for less, don't crush what you fetched.

for one function — don't pull a whole 800-line file to answer about a 10-line body.

lines (`def`/`class`/`function`/`export`) for a skeleton, then `Read` only the bodies

you need — the outline answers most where/what questions without paying for the file.

tracks file state; re-Reading an unchanged file just re-pays for it.

`eson retrieve <hash>` restores it verbatim when a detail is needed. (Lossy-skim variant for

huge uniform arrays: `eson crush`.) Reference the handle instead of pasting the blob again.

return is itself a Lever-3 handoff: columnar/minified.

bulk (≥~6k chars you'll skim but never edit or byte-copy) as PNG pages:

`npx pxpipe-proxy export --json --out <tmp> <target>`, then `Read` the `page-*.png` **and**

`factsheet.txt` (~5× cheaper; Fable-class readers only). Lossy on exact strings — `Grep`-verify

anything exact before acting on it, and never PX a file you will `Edit`. Guards: `honey-px`.

Carve-outs inherit Lever 3: never elide auth/secrets/migrations/deletes or anything the user

asked for, and never drop a payload about to be written back verbatim.

Loops — cost compounds per tick

A `/loop` multiplies per-tick cost by tick count, so waste compounds. The levers

above still apply each tick; loops add two leaks the single-shot levers don't cover

— re-paying for context every wake-up, and re-doing work that didn't change:

amortizes one cache miss over a long idle wait. **Never ~300s** — it pays the miss

without amortizing. Idle default **1200–1800s**.

you on completion; set a long fallback heartbeat and let the notification drive.

Poll only external state the harness can't see (CI, deploy, remote queue).

unchanged → one status line, reschedule, skip the redo. Per-tick output defaults to

**ultra**; step up only on the tick that needs the user.

Full version: the `honey-loop` skill.

Examples

Read a JSON file's key:

> ```python

> import json

> def read_json_value(path, key):

> return json.load(open(path))[key]

> ```

> Raises `KeyError`/`FileNotFoundError` — fine for a trusted path. `.get(key, default)` if optional.

Stdlib already does it → no code:

> `copy.deepcopy(d)` — no utility needed.

Precision kept, prose gone:

> `pytest tests/ -q` · `-k <name>` runs one test, `-x` stops on first failure.

<!-- claude-code-only -->

Toggling (`/honey` in Claude Code)

Only when the user explicitly invokes `/honey [lite|full|ultra|off]` (or asks to

turn Honey on/off) — not when this skill loads reflexively — persist the state

first by running exactly:

`node "${CLAUDE_PLUGIN_ROOT}/hooks/honey-state.js" set $ARGUMENTS`

(If `CLAUDE_PLUGIN_ROOT` is unexpanded, `hooks/honey-state.js` lives at the

plugin root, two directories above this file.) Empty argument = `full`. Then act

on the script's output:

this skill at that intensity for the rest of the session. No need to re-run

`/honey` next session — the SessionStart hook re-activates it until `/honey off`.