Tyler Garrett

Most AI coding tools measure themselves by what the model can do. We spent the beta measuring what it shouldn't have to do — every token the agent burns on something the UI could've just done directly is a token wasted. That discipline is the actual product.

The under-the-hood stuff

Every agent run is capped at 10 steps, on purpose

The loop doesn't wander. It gets 10 iterations to read, edit, and verify — then it stops and hands control back, rather than spiraling through redundant re-reads and "let me also check…" tangents. A single orchestrated step (read → edit → done) gets an even tighter cap. Slower isn't the failure mode we're avoiding — runaway spend is.

A real token budget gate, not a vibes-based one

At 150k tokens spent on a single request, you get a heads-up. At 300k, the loop physically pauses and waits for you to say "keep going." No silent meter climbing in the background — the system stops itself and asks.

The preview button starts the app. The AI doesn't.

This is the one that actually matters: when you click preview, the editor spins up the real dev server directly — no LLM call involved. Every system prompt in the agent explicitly forbids the model from running npm run dev, vite, astro dev, or any serve command to "check its work," because the dev server is already running and hot-reloading. Asking the AI to start your app is asking it to spend tokens duplicating something a button already did for free. We removed that whole category of waste.

Cache-aware by construction

The conversation window is managed to keep a stable prefix instead of shifting on every turn — because a byte-for-byte stable prefix is what makes prompt caching actually work. Get this wrong and you silently re-pay for the same context on every single call. We measured this directly and tuned the eviction policy around it, not around convenience.

Why this is the beta, not a footnote

Anyone can wire an agent loop to a model and call it a coding assistant. The interesting engineering problem is making that loop cheap to run for hours — bounded steps, a real spend gate, and infrastructure (preview, hot-reload) that does its job without asking the model to do it for you. That's the ecosystem: not just an assistant that codes, but one that knows when not to think.

Try it

YeeYee is a local-first Electron app. Beta access details to follow.

Made by dev3lop.com.

We build Yee, a local-first AI coding editor. Most weeks we ship features. This last stretch turned into something a little different: we set out to audit how honestly the app measures its own token spend, and the audit kept finding new ways the meter had been lying to us — not maliciously, just quietly, the way instrumentation always does when nobody's checked it against reality in a while.

Here's what that turned into, and a few unrelated things that shipped alongside it.

The meter was wrong. Then it was wrong again. Then again.

It started with a simple complaint: the dollar estimate on a session read ~$25. The real Anthropic invoice for that same session was ~$3.4. Root cause — the estimator priced every token type (input, output, cache read, cache write) at one blended rate, when in reality output costs roughly 5x input and a cache read costs about 10% of input. Fixed by pricing each token type separately, per model, and locking the fix with a test that replays the exact real session and asserts it prices to $3.5 — not the old $25.

That fix made the meter trustworthy enough to notice the next problem: a real agent-loop session had read only 4,329 of 98,741 input tokens from cache — 4%, when message-prefix caching should have delivered something like 95%. Almost the entire session cost was cache writes, not reads. Tracing it down: at the max-turns cap, history trimming shifted the message array by exactly one slot on every turn, which broke the byte-identical prefix the cache depends on — every single call. The fix (a "floor" that trims down in one shot instead of shaving one message at a time) took the at-cap rewrite rate from 100% down to 22%, and the shared-prefix rate from ~20% up to ~87%. Measured honestly, in dollars: about $0.60 down to about $0.10 for the same work.

Then we found the meter wasn't just miscalibrated — for a whole class of sessions it was reading zero. The start-screen token-history grid was blank; per-conversation totals vanished on restart. The database had 0 rows in its usage-hours table despite months of real multi-message chats. The cause: the API gateway that the default model path routes through simply never forwarded a usage field in its responses, so the code that feeds the meter hit an early return and silently no-op'd — for the meter, the per-chat total, and the historical charts, all from one dropped field. Local-model (Ollama) spend had the same blind spot for the same reason. Fixed by normalizing and forwarding usage at the gateway boundary, for both backends, on both streaming and non-streaming paths.

Three separate, real bugs, found by comparing what the app claimed against what actually happened — not by design review, but by checking. That's the pattern we're trying to hold ourselves to: an instrument only earns trust once someone's tried to catch it lying and failed.

Alongside the audit: real caching, a real circuit breaker, and a local-model summarizer that costs nothing

The same two weeks shipped the actual token-saving mechanisms the meter now measures honestly:

• Message-prefix caching went live — every agent-loop call now cache-marks the growing conversation, not just the system prompt, so a live-probed follow-up call read 99.7% of its input from cache instead of paying full price to resend the whole transcript.
• A pinned task, an unpinned middle. History eviction used to drop the original task first, since it was the oldest message — exactly the thing a long-running loop can't afford to forget. Now the first task+context pair is pinned for the life of the conversation, and only the middle evicts.
• A real budget circuit breaker. Nothing used to stand between a runaway loop and an unbounded bill. Now a soft warning lands at 150k tokens per turn, and a hard pause at 300k — with a "keep going" button that requires an explicit choice to spend another 300k, and (as of this stretch) an actual stop option, since the pause used to only offer "keep going" and the send button would silently do nothing mid-run if you tried to interrupt it.
• Context compaction that costs zero API tokens. When history has to be dropped, instead of just deleting it, Yee now asks the locally-forged model — running on your own hardware — to summarize the span being evicted. It falls back silently to plain eviction if the local model is slow or unavailable, so it never adds latency risk to a paid call.
• Native tool calling (Anthropic, opt-in via flag). The text-based tool protocol Yee uses everywhere else means every formatting slip costs a full extra round-trip to self-correct. Native mode lets the API carry tool calls directly, which removes that failure mode and about 600 tokens of format-teaching from the system prompt — currently opt-in while it proves itself.

Elsewhere in the app

Not everything this stretch was about tokens:

• A live system map. An interactive, hover-to-trace diagram of the whole editor — 38 nodes, 56 connections, built from an actual sweep of the code rather than hand-drawn, with each node honestly marked shipped, partial, or untested. If a feature isn't wired up yet, the map says so instead of implying otherwise.
• The training dashboard, embedded. The existing Forge dashboard — where edits you approve become local training data — now opens inside the editor itself as a third launch option, instead of living in a separate app you'd have to know to go find.
• Real Lighthouse scores in the chat header. Four live performance/accessibility/best-practices/SEO scores for whatever you're previewing, with a queue that lets you fix failing audits one focused turn at a time instead of dumping all nine problems into a single overwhelming prompt.

The takeaway

None of this is a "we're 50% cheaper now" headline, and we're deliberately not writing it as one — the honest number is that fixing three measurement bugs and one real caching bug got a specific session from about $0.60 to about $0.10, which is a real and meaningful improvement, not a universal multiplier. The more durable point is the process: build the thing, then go looking for the ways it's lying to you, and don't stop at the first bug you find.

Hi, I'm a successful vibe coder, and this is how I use my claude.md... These rules govern how we build and run. I'm releasing this because I want others a chance to lower the costs of their implementations and see what successful AI full-stack engineers/coder are using with their solution. This is a small claude.md file, it helps teach claude how to manage the repository while I work with it. I feel this particular setup is good for early projects, before they go online, or have any users.

Rule 1 — No ghosting: reusable tech lives in `/scripts/`

Every tool, shell command, query, or operational step that is reusable MUST be a committed file in /scripts/. Do not run know-how ad-hoc in a terminal and lose it. If you run something twice, or it encodes how the business works, script it and wire an npm run alias in package.json. One-off throwaway inspection is fine; anything that is "how we do X" is a script. This is how we avoid losing the tech.

Current scripts: init-db, import-targets, discover, geocode, passive-scan, chrome-recon, rollup, daily-charts, export-dashboard, agent, evolve, hunt, crawl, engage, demonstrate, blog, report, reset, repo-map, guard-confidential, deals, mailer, track, deploy.

Rule 2 — Internal-facing by default; nothing real goes public

Discovered targets, findings, posture scores, leads, and demonstration evidence are CONFIDENTIAL / internal-facing. We do not publish "here are local sites and their bugs." Concretely:

• The dashboard (apps/dashboard) and charts/ are INTERNAL — run locally or behind

auth, never deployed to the open web.

• The public marketing site (apps/marketing) uses only fictional/aggregate examples

for its generic, anonymous content. npm run guard fails the build if any real target host leaks into that generic content.

• The one deliberate exception is the self-serve portal (/portal, backed by

scripts/track.mjs's /api/): a business's own real name, domain, and findings are shown back to that business only, gated by the signed identity cookie minted when they scan their own* printed QR code (lib/session.mjs). This is not "publishing" — it's a client reading their own report. The hard invariant: every portal endpoint resolves the business strictly from the signed cookie, never from a client-supplied id/host/param, so scanning business A's QR can never surface business B's data. Anonymous visitors (no valid cookie, the overwhelming default) always see the generic content, never anyone's real data.

• Engagement evidence lives in engagements/ (gitignored) and is shared with the client

privately, never posted.

Rule 3 — Passive by default; active only under signed authorization; demos are safe

• Lead-gen recon is passive (browser/dig-equivalent). See [agents/_shared/ethics.md](./agents/_shared/ethics.md).
• The portal's "Recheck now" button (POST /api/rescan) runs the exact same passive checks

as npm run scan, on-demand, against the domain tied to the caller's own identity cookie — a site owner re-checking their own site is still passive recon, same as any browser visit. It stays inside Rule 3 because the target is never client-controlled (always the cookie-bound business's own domain) and rate-limited (RESCAN_COOLDOWN_MINUTES) so it can't be repurposed into a probe of anything else.

• When a lead asks us to prove a finding is real, we run the demonstration protocol

(npm run demonstrate <host>) — but only after npm run engage -- authorize … records a signed scope (note the --: it forwards flags through npm). Demonstrations are non-destructive (GET, TLS handshake, client-run PoC files); they never tamper, bypass auth, or exfiltrate real data.

• traits.risk_appetite stays 0 forever (evolution may not raise it). Authorization —

not a trait — is what unlocks the active lane. See [knowledge/90-demonstration-protocol.md](./knowledge/90-demonstration-protocol.md).

Rule 4 — Stack & cadence

React + Tailwind + Vite for apps; Astro for marketing. Analytics-first: charts over words, every day (npm run day → charts/index.html + dashboard). Every finding cites a security.md section.

Right now I my knee and going between the ice tub and the hot tub. I’m coming to the realization that a lot of people are very strong in this sport due to supplements, and if I’m going to be at that same tear or level,… I guess that means I also need to find out more my last few sparring sessions. I remember feeling my partner’s muscles, which sounds a little weird, but you have to understand these people are absolutely dominating me and I’m very interested. This is definitely the scariest injury I’ve ever had in my lifetime and I’m very fortunate that I’m able right now to walk on my knee and not in the hospital. What’s funny is you would think that something like this would make me not want to do Brazilian jujutsu but all I’m thinking about is how I can find one of the best people in the world to train with because I want to learn and I wanna keep going and I don’t mind the injuries as much as I thought I would. End of the day I’m hurting myself. My ego and my pride are still dying.

I don’t do a ton of pictures of the people I train with but this one I did. I think this was one of my favorite classes to. Was able to tape my fingers up, didn’t open the skin on that hand again. Def fucked my knee something pretty but met with exercise guru today who said I’m okay ✅ … but have to be careful next 24hrs