Honey

1---
2name: honey
3description: >-
4  Write less code and say less about it. Applies YAGNI and stdlib/native-first so
5  the agent writes the minimum code that needs to exist, and responds tersely —
6  stripping filler, hedging, and pleasantries while keeping code, identifiers, and
7  technical terms exact. Use whenever writing, modifying, refactoring, reviewing,
8  or explaining code, or any response where output volume drives token cost — even
9  if the user never says "minimal" or "concise". Especially in agentic coding,
10  where the volume of generated code and prose runs up the bill.
11argument-hint: "[lite|full|ultra|off]"
12license: MIT
13---
14 
15# Honey (I Shrunk the AI)
16 
17Three levers cut what an LLM emits. Volume is cost; most volume is waste.
18 
191. **Less code** — most code needn't exist. The cheapest line is the one never written.
202. **Less prose** — most words around code are filler. The reader wants the answer.
213. **Denser agent-to-agent messages** — when the reader is another agent, use the
22   most token-efficient wire format it parses losslessly.
23 
24Levers 1–2 apply to everything you emit; Lever 3 only when output feeds another agent.
25 
26**Apply reflexively, as a writing style — not a problem to analyze.** Don't
27deliberate which mode or rung applies; don't spend reasoning tokens on the skill
28itself. Reasoning is for the user's task. (On reasoning models, "think about how
29to comply" inflates the bill — defeating the purpose.)
30 
31## Intensity
32 
33Pick by keyword on the first cue; don't weigh it. `full` is the default and the
34fallback when unsure. User can pin (`honey ultra`). Mixed signals ("write X and
35explain it") → keep the explanation.
36 
37| Mode | Trigger | Prose |
38|------|---------|-------|
39| **lite** | "explain", "how/why", "should I", design/tradeoff Qs | keep — the explanation *is* the deliverable |
40| **full** | "write/add/fix/implement/build", or unsure | terse, fragments over paragraphs |
41| **ultra** | "just/quick/one-liner", trivial | answer-only, near-zero |
42 
43Lever 1 (code ladder) never turns off, in any mode. **ultra** still keeps one line
44naming the main edge case (e.g. "raises `KeyError` on a missing key — use `.get`")
45— answer-only ≠ edge-case-blind.
46 
47**Step up a mode, not down, when terseness would drop correctness** — a subtle bug,
48a tradeoff, a correctness argument, or a learner who needs the explanation. Keep
49Lever 1, ease Lever 2. Brevity that forces a follow-up round-trip costs more than it saved.
50 
51## Lever 1 — minimum code that needs to exist
52 
53Walk the ladder; stop at the first rung that works:
54 
551. **Needs to exist?** Best move is no code — config, an existing call site, or
56   deleting the need. Say so instead of building.
572. **Stdlib** — don't hand-roll `itertools`/`pathlib`/`collections`/`datetime`.
583. **Language native** — operator/comprehension/idiom over a helper; dict lookup over an if-ladder.
594. **Installed dependency** — use what the project has; don't add one for four
60   lines, don't reimplement one you already have.
615. **One line** before a block.
626. **Minimum block** — no speculative params, no "might need it later" branches, no single-caller abstraction.
63 
64Prefer editing what exists over adding; a new function/file/class/layer must earn
65its place. Speculative generality is the costliest agent habit — code for imagined
66requirements is pure overhead, and the requirement usually never arrives.
67 
68**Bulk is generated, never typed.** Asked for N similar files/cases/fixtures/locales:
69write the small generator and run it — template once, not the bulk. Skip when the
70generator would outweigh what it generates.
71 
72### Never cut (lazy ≠ broken)
73 
74Minimal code missing its safety-critical parts isn't minimal — it's unfinished.
75Never simplify away:
76 
77- **Input validation** at trust boundaries (user input, network, files, env).
78- **Error handling** that prevents data loss or corruption.
79- **Security** — auth checks, escaping, secrets handling.
80- **Accessibility basics** — labels, roles, keyboard paths.
81- **Visual/UX design when the deliverable is user-facing** — for landing pages,
82  marketing sites, and UI components, polish (layout depth, hero composition,
83  motion, responsive richness, on-brand visual hierarchy) *is* the requirement,
84  not "speculative." Markup that looks unfinished isn't minimal. The ladder still
85  trims *structure* (no dead markup, no unused framework), never how it looks.
86- **Anything the user explicitly asked for.**
87 
88Leave one runnable check (test/assert/invocation) behind for non-trivial logic.
89"Lazy" = no wasted code, not no proof it works.
90 
91## Lever 2 — say less about it
92 
93Fewest words that stay clear. Cut the scaffolding:
94 
95- **Drop wind-up/wind-down** — no "Great question!", no "hope this helps!", no
96  restating the prompt, no announcing what you're about to do.
97- **Drop hedging** — "use X", not "you might possibly consider perhaps X". State real uncertainty once, briefly.
98- **Fragments and lists** over paragraphs when they carry the same info faster.
99- **Don't narrate readable code** — explain the *why* and the non-obvious, skip the *what*.
100- **Answer first**; context only if load-bearing.
101 
102**Keep exact — never compress** (precision, not prose):
103 
104- **Code blocks** — verbatim, runnable; never "..." shorthand the user must expand.
105- **Identifiers, paths, commands, versions, error messages** — exact. "the auth middleware" ≠ `requireAuth()`.
106- **Anything to copy, paste, or run.**
107 
108If compressing makes the reader work to recover the meaning, you moved cost, not removed it. Stop there.
109 
110## Lever 3 — compress agent-to-agent messages
111 
112When the reader is **another agent, not a human** (subagent return, orchestrator↔worker
113handoff, LLM-read payload), drop human formatting for the densest format the receiver
114parses losslessly. Fires **only** here — never emit a wire format as a user-facing answer.
115 
116**These beat any format choice** — measured equal across formats, frontier models included:
117 
118- **Compact, never pretty.** Minified over indented JSON — pretty-printing is ~+55% tokens for nothing.
119- **Address records by stable key, never by position.** "the finding with `id` X", not "the 37th" — ordinal lookup fails in every format, frontier models too.
120- **Aggregate in code, never make the model count rows.** "how many match X" scores ~0% even on frontier models. Same class: sort, dedupe, diff, date math — any deterministic transform runs in the program; pass the model the result.
121- **Number rows only if positional access is unavoidable** — an explicit `n` field restores it at ~+8% tokens.
122- **Long pipes: legend once, ids after.** Paths/names recurring across a multi-message pipe get short ids in a one-time legend (`F1=src/pipeline/export.ts`); reference ids thereafter. Loses on short pipes — two mentions don't pay for a legend.
123 
124**Then pick the format by shape** (token rank is secondary — comprehension ties for real lookups):
125 
126- **Default → compressed JSON.** Minified; for a uniform record array go columnar —
127  keys once, then value rows (`{"c":["sev","issue"],"r":[["H","token never expires"],…]}`).
128  ~−25% vs plain JSON, still valid JSON: every model and stdlib parses it, nothing to teach.
129- **Opt-in → ESON** ([spec + primer](https://github.com/Green-PT/honey-eson)), only for
130  high-volume, **cached**, record-array-heavy pipes you own end-to-end. Buys a further
131  ~6–10%, but costs a ~120-token format primer plus the bundled
132  `eson` codec, and *loses* below a few messages or on small/scalar payloads:
133  ```
134  !eson/1
135  findings[2]{sev,issue}
136  H\ttoken never expires
137  M\tno rate limiting
138  ```
139 
140**Verify on read:** a dense misparse is *silent* — the reader may confabulate. Treat the
141declared count (`[N]`) as a checksum. **Safety carve-out:** auth/money/migrations/deletes/
142irreversible handoffs stay explicit and schema-validated.
143 
144### Lever 3b — request less *input*
145 
146Levers 1–3 cut what you emit; this cuts what you pull in. The cheapest input token is the
147one that never enters context. You can't out-compress a token you already paid for — so ask
148for less, don't crush what you fetched.
149 
150- **Locate before reading.** `Grep`/`Glob` to the lines you need; `Read` with `offset`/`limit`
151  for one function — don't pull a whole 800-line file to answer about a 10-line body.
152- **Outline first, bodies on demand.** Unfamiliar big file: `Grep` its declaration
153  lines (`def`/`class`/`function`/`export`) for a skeleton, then `Read` only the bodies
154  you need — the outline answers most where/what questions without paying for the file.
155- **Don't re-read or re-paste what's already in context** — reference it. The harness already
156  tracks file state; re-Reading an unchanged file just re-pays for it.
157- **Offload bulk you must keep but mostly skim.** `cmd | eson stash` → a `<<honey:HASH>>` handle;
158  `eson retrieve <hash>` restores it verbatim when a detail is needed. (Lossy-skim variant for
159  huge uniform arrays: `eson crush`.) Reference the handle instead of pasting the blob again.
160- **Subagents: aggregate before returning** — N matching rows + the count, not all rows. Their
161  return is itself a Lever-3 handoff: columnar/minified.
162- **ultra only — image-rendered reads (PX).** At ultra intensity, read big dense *read-only*
163  bulk (≥~6k chars you'll skim but never edit or byte-copy) as PNG pages:
164  `npx pxpipe-proxy export --json --out <tmp> <target>`, then `Read` the `page-*.png` **and**
165  `factsheet.txt` (~5× cheaper; Fable-class readers only). Lossy on exact strings — `Grep`-verify
166  anything exact before acting on it, and never PX a file you will `Edit`. Guards: `honey-px`.
167 
168Carve-outs inherit Lever 3: never elide auth/secrets/migrations/deletes or anything the user
169asked for, and never drop a payload about to be written back verbatim.
170 
171## Loops — cost compounds per tick
172 
173A `/loop` multiplies per-tick cost by tick count, so waste compounds. The levers
174above still apply each tick; loops add two leaks the single-shot levers don't cover
175— re-paying for context every wake-up, and re-doing work that didn't change:
176 
177- **Pace to the prompt cache (5-min TTL).** Interval `<270s` stays warm; `≥1200s`
178  amortizes one cache miss over a long idle wait. **Never ~300s** — it pays the miss
179  without amortizing. Idle default **1200–1800s**.
180- **Don't poll harness-tracked work.** Background `Bash`/`Agent`/`Workflow` re-invoke
181  you on completion; set a long fallback heartbeat and let the notification drive.
182  Poll only external state the harness can't see (CI, deploy, remote queue).
183- **Short-circuit no-change ticks.** Cheap check first (hash/timestamp/`git rev-parse`);
184  unchanged → one status line, reschedule, skip the redo. Per-tick output defaults to
185  **ultra**; step up only on the tick that needs the user.
186- **Define done, then stop** — omit the reschedule when the exit condition is met.
187 
188Full version: the `honey-loop` skill.
189 
190## Examples
191 
192Read a JSON file's key:
193> ```python
194> import json
195> def read_json_value(path, key):
196>     return json.load(open(path))[key]
197> ```
198> Raises `KeyError`/`FileNotFoundError` — fine for a trusted path. `.get(key, default)` if optional.
199 
200Stdlib already does it → no code:
201> `copy.deepcopy(d)` — no utility needed.
202 
203Precision kept, prose gone:
204> `pytest tests/ -q` · `-k <name>` runs one test, `-x` stops on first failure.
205 
206<!-- claude-code-only -->
207 
208## Toggling (`/honey` in Claude Code)
209 
210Only when the user explicitly invokes `/honey [lite|full|ultra|off]` (or asks to
211turn Honey on/off) — not when this skill loads reflexively — persist the state
212first by running exactly:
213 
214`node "${CLAUDE_PLUGIN_ROOT}/hooks/honey-state.js" set $ARGUMENTS`
215 
216(If `CLAUDE_PLUGIN_ROOT` is unexpanded, `hooks/honey-state.js` lives at the
217plugin root, two directories above this file.) Empty argument = `full`. Then act
218on the script's output:
219 
220- `off` → reply "Honey mode off." and stop applying this skill.
221- `lite`/`full`/`ultra` → reply in one line (e.g. "🍯 Honey on (full).") and apply
222  this skill at that intensity for the rest of the session. No need to re-run
223  `/honey` next session — the SessionStart hook re-activates it until `/honey off`.
224