agentleFS
srfinch17srfinch17/peckworks-skills-laboratory/skills/stretching-frontier-tokens/SKILL.md

stretching-frontier-tokens

Skill0 starsChanged 47 days agoMITView on GitHub

Use when the strongest available model is usage-capped or rate-limited and its quota is the bottleneck on real work - "I only get a day or two before my limit resets", burning frontier tokens on mechanical work, transcripts dominated by screenshots or tool round-trips, or planning how to split a working loop across model tiers. Also use before spawning subagents to save quota, to decide what must NOT be delegated.

The file

We split this skill into the rules it gives an agent

1 rule. About 0 are common, 1 is distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    One agent owns the diff: when a one-change-per-round law is in force.

    line 45

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Stretching Frontier Tokens

When the frontier model is the scarce resource, spend it only where the frontier matters. The failure this prevents: the strongest model does 100% of a loop - including screenshot choreography, boilerplate plumbing, and log formatting - and the human's quota dies in a day.

Measure the transcript before theorizing

Session transcripts live on disk (~/.claude/projects/<project>/*.jsonl). Have the CHEAPEST model aggregate them: bytes by message type, base64/image line counts, tool-call counts by name, largest lines. Observed baseline that motivated this skill: images were 76.7% of session bytes (48 screenshots, all 10 largest lines), plus 425 interactive browser tool calls and an 18k-token instructions file injected into every session - none of it frontier work. Your sinks will differ; measure first, then cut the biggest.

The ladder (climb down before spending up)

  1. Script it. Fixed choreography (drive a browser, crop images, parse a log, run tests) is a CLI call returning a text manifest - not N tool round-trips each carrying payloads through the frontier context. Build the script once; it costs zero tokens forever after.
  2. Cheapest capable model, via subagent. Mechanical transforms, formatting, forensics -> cheapest tier. Vision digests, blind-gate judging, delta comparison -> mid tier (naive eyes are often what a blind gate WANTS). Implementation from an explicit spec -> strong-but-cheaper tier.
  3. Frontier only for: diagnosis of WHY (the documented rate limiter in judgment loops), design of the mechanism/law, and prose aimed at the human (questions, trade-offs, verdicts).
  4. Session-level: routine pattern-following rounds can run as whole sessions on a cheaper model with the laws in project memory; book frontier sessions for representation changes, complaints that survived two fixes, and consolidation.

Delegation guardrails (each from a real failure)

  • Delegate only terminal outputs - a number, a file path, a passing suite, a commit. Never a judgment the frontier model would re-derive from the raw data: that pays twice.
  • No delegation under ~10k tokens of work - re-priming costs more than it saves. Prime subagents with one frozen ~60-line round brief, never the full instructions file.
  • Raw human words pass through unsummarised. A digest may add coordinates and adjacency; the human's verbatim sentence always reaches the frontier model.
  • Integrity checks live in scripts, not in cheap models - a cheap runner will never notice a lying rig; a script can assert echoed tags and refuse mismatched output.
  • One agent owns the diff when a one-change-per-round law is in force; check git diff --stat against the expected file list.

Cut the fixed taxes

Everything injected into every request is a tax multiplied by every turn: instruction files that accumulate history (split to an operational core + a history doc), index files bloated into paragraphs, full-frame images left sitting in context (crop to the marked region, downscale, cap per decision, and prefer a subagent reading the image and returning text).

Do not economize on

The human's capture channel and any append-only judgment record. The human is still the scarcest resource; a token saved by degrading their signal is the most expensive token in the system.

Writing the delegation contract (from the first real tiered run)

Quality tracked contract precision, not model tier. Four rules, each observed:

  • Demand evidence, not code. Contracts that required verbatim result lines and live verification got agents that verified BEYOND spec (one drove the real app to prove generated DOM matched deleted markup and cache keys were unchanged; another tested the failure path unasked). Contracts that only ask for code get code.
  • Mark your claims as beliefs. A prompt asserted a dependency existed "from prior rounds" - false, and a good agent falsified it (package manager + lockfile + history) and routed around it. State repo-record claims as "verify before relying"; an agent contradicting your prompt is the system working.
  • The orchestrator owns the seams. Strict per-agent file ownership prevents collisions but creates gaps exactly at the boundaries (an agent barred from the manifest installed a dependency unpinned). After a fan-out, review the seams - cross-file contracts, manifests, registration sites - not just each diff.
  • Stop background processes before dependency installs - your own dev server holding a native module produced EBUSY mid-integration.
  • Keep the words that will be SPOKEN or SENT; delegate the words that will be READ. On a run with the frontier quota nearly exhausted, the orchestrator hand-wrote only the five verbatim scripts the human would read aloud in a live meeting, marked them "insert exactly as written, do not reword", and delegated every other word: teaching prose, layout, diagrams, a companion card, and the verification passes. The scarce model's output should be the artifact with the lowest tolerance for paraphrase, not the one with the largest word count. A subagent asked to improve copy will improve it, which is correct behavior and the wrong outcome when the copy is a script someone rehearses.
  • A deliberately narrowed QA gate is a trade, not a shortcut, and it has to be logged as one. Under a hard quota ceiling, a full multi-lens gate was replaced by one verifier armed with the four defect classes that actually mattered for that artifact; it returned nine real findings. Record the narrowing wherever the artifact's provenance lives, so a later reader knows which lenses never ran and can run them when the quota returns.

Testing note

Written from an observed baseline (one session where the frontier model did everything; numbers above), not staged pressure scenarios - the maintainer has a standing instruction against dispatch-heavy skill testing. Treat as unvalidated under pressure; tighten on first recurrence, recording the rationalization used. First execution same day: a 3-model review fan-out + a 3-agent build fan-out moved ~615k tokens of work off the frontier quota with zero collisions; the contract rules above were added from what that run showed.

Provenance

  • 2026-09-02: a 21-file Feynman rewrite plus ten cold reads ran on ~30 Sonnet-class agents (reads 156k-208k each, pair rewrites 130k-310k, one 220k picture sweep that found what four full reads missed) while the frontier wrote only the charter, the analogy seeds, the catalog entries and the diagnoses and never read a walkthrough end to end. Two waves of 9-12 agents died on the human's five-hour limit; waves of 3-4 with write-the-file-first agents finished with zero kills. A 34 KB single Write hit the 64k output cap; assembly by script from small pieces did not.

Field validation: the human named the split himself, and the frontier share turned out to be the review gate

Mid-session the user asked for a sanity check: was the only part of a resume-tailoring workflow that needed a frontier model the customization step itself, with everything else being grunt work? Yes, with one addition that the same week had demonstrated twice: two cheap-agent deliverables (a dashboard CSS feature, then a follow-up with web-search logo hunting) each reported grep counts that were all correct while the rendered page was broken in a way only a screenshot showed. The frontier model's irreducible share is the review gate on what cheap agents return: read the diff, render the output, verify the report's claims. Grunt that moved off the frontier model: link extraction, dedup, folder metadata, generate and audit runs, tracker and dashboard refreshes, per-company logo lookups (about 300k Sonnet tokens for 40 web searches, acceptable where the frontier model would have spent the same plus its own reasoning). The lever that makes the split pay is BATCHING: per-item inline work by the frontier model costs about the same as briefing an agent per item, so the agent must take a day's worth of items and return only the short list that needs frontier judgment.

Field validation 2: a whole feature run on the tiers, and where the frontier share actually went (2026-09-09)

peckworks-cadmesh DEV-RUN-2: 17 tasks, every one implemented by Opus or Sonnet from a brief (page + delta + scope contract), reviewed by a fresh Sonnet/Opus reviewer, 11 fix rounds, a whole-branch review, ~40 dispatches, ZERO frontier tokens on implementation. The frontier share was: the plan, the nemesis fixes, one dispatch brief per task (~40 lines each), the rulings (33, all ledgered), and the seam checks between runs. Three things the run proved about the contract: (1) executors PREDICTING before running is what makes cheap executors safe: they refuted five claims in my own briefs (a wrong count, a wrong sign, a wrong variable name, a wrong "this was already added", a security sentence inverted); (2) a reviewer that REBUILDS the table from the file (all 15 endpoints: method guard + origin guard

  • root handling) is worth more than one that reads the report; (3) Opus session limits are a live constraint (two 429s); resuming the same agent after the reset kept its context, and a Sonnet fallback for mechanical tasks cost nothing. Full ledger: repo DEV-RUN-2.md section 6.

Field case 2026-09-10 — DEV-RUN-3 (cadmesh), 8 tasks, tiered

Haiku transcribed a brief that carried complete code correctly on the first pass (the two fix rounds it drew were a reviewer's pedantry about a temp-file path). Sonnet implementers on integration tasks each disclosed something the brief had not anticipated (a lock deadlock, an orphan worker, a second race) — their "Concerns:" line was the highest-value output of the run. Sonnet task reviews found real Importants in 5 of 8 tasks but never an interaction bug; the one Opus whole-branch review found the Critical (a queued second release landing the first build silently) that lived between two correct tasks. Rule confirmed with numbers: cheapest tier for transcription, mid tier for integration and per-task review, the strongest model ONLY for the whole-branch pass — and never skip that pass to save tokens, it is where the expensive bug was.

Field case 2026-10-16: two helpers in parallel on a visual build, and what the frontier share bought

Sakura Pond round fifteen: the frontier model fixed the owner's two look complaints and rebuilt the turtle itself (measured, not delegated: the instruments decided what was wrong), then briefed two cheaper helpers in parallel, each in its own copy of the repo (git archive HEAD | tar -x), with a pattern file to copy, may and may-not-touch lists, the comment style, the instrument routine with the numbers to report, and "never launch full screen". Goldfish (a second fish kind on the koi's body and mind): 249K, 22 min, usable. Mouse (a new land animal on the shared trail and walking kit): 271K, 41 min, usable. Both helpers' own weak-spot notes were right (a khaki tail fin; a subtle sit-up) and were acted on at the merge. Where the frontier share went, in order of value: the two briefs; the three-way merge (a small script, LF-normalised git merge-file, conflicts only on doc table rows); the look review of each sheet; running the FULL pond timeline on the merged build, which found that a weighting the frontier model itself had added put every fish into one behaviour (the helpers could not have seen it: it was not in their scope); and the adversarial review round, which the helpers' own checks cannot replace (a helper tuned a visit gap against a visibility count its own fade bug had inflated). Rule confirmed: delegate the making of a bounded piece with a pattern and a proof; keep the brief, the merge, the whole-system measurement and the review.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.