YeeYee Devlog, July 2026 — Token Honesty, Git Manners, and a Notarized Mac App

A changelog for everyone following along. Last time, the whole project arc told the full story of YeeYee — a local-first, offline-capable AI code editor whose thesis is the agent does the work — and ended at roughly "feature-complete, validation remaining." This is what happened in the seventeen days after that post. Short version: feature-complete became shippable, and dogfooding taught us more than any benchmark did.

TL;DR

• YeeYee is now a real Mac app. Signed, notarized by Apple, Gatekeeper-clean DMG. Double-click,

drag to Applications, done — no right-click-to-open ritual.

• The token meter now tells the truth. Cost estimates used to run ~7× high; they now match the

provider's own console to within pennies. A prompt-cache bug that was silently re-writing context on every call got found, proven by replay, and killed — one measured session dropped from $0.60 to about $0.10.

• The agent learned git manners. It commits only what it actually touched, fact-checks "will this

deploy?" before every push, does real rebases with a recoverable safety net, and writes pull-request descriptions that tell the story of the conversation that produced them.

• The live preview got street smarts. Multi-app repos get a launcher, backend services are treated

as services (not broken web pages), port conflicts get diagnosed instead of "fixed," and Lighthouse scores sit in the chat header with a one-click path to fixing them.

• We stopped running paid internal evals — and shipped the measurement tooling to users instead.

More on why below; it's the most honest decision in this post.

1. Shipping a real Mac app (July 12 → 25)

The arc post ended with an editor that worked great — on the machine it was built on. Getting from there to "a stranger double-clicks a DMG and it just works" turned out to be its own project.

• July 12 — a one-command installer build, a launch-readiness audit that surfaced four

ship-blockers (all fixed), and a safety-hardening pass over the surfaces that could actually hurt a user: file edits, secrets handling, the terminal, and the embedded webview.

• July 21 — a turnkey code-signing and notarization pipeline: one command preflights the

credentials, signs with hardened runtime, notarizes, staples, and verifies the result.

• July 25 — the first fully notarized DMG, verified accepted — Notarized Developer ID at both

layers. Plus the cosmetics a real app deserves: a proper app icon and a styled installer window instead of a bare dark rectangle.

Two hard-won lessons for anyone shipping an Electron app on macOS, because these cost us real days and the internet's answers were thin:

1. Apple's G2 intermediate certificate must live in a persistent keychain. Modern Developer ID

certs chain through an intermediate that macOS doesn't ship. With it missing, codesign fails intermittently — roughly four runs in five — which means one lucky green build proves nothing. One certificate import and the pipeline went thirteen-for-thirteen.

1. Notarizing the app is not notarizing the DMG. The standard tooling happily notarizes the .app

inside while leaving the DMG container itself unsigned — and Gatekeeper judges the thing the user actually downloads. Sign, notarize, and staple both layers, and verify both.

And then dogfooding the installed app immediately paid for itself: launched from the Dock, the live preview died with spawn npm ENOENT. Apps launched from Finder get the OS's bare PATH — not your shell's — so every developer tool the app shells out to is invisible. The fix (capturing the user's real login-shell environment at boot, the way the big editors do) closed the same hole in three other features that would have quietly broken for every beta tester.

2. The token meter now tells the truth (July 16 → 18)

If you've read the earlier posts, you know the standing rule here: no headline without a measurement. This month the measuring instruments themselves got audited, and the findings were humbling in both directions.

• Cost estimates ran ~7× high. The meter priced every token at one blended rate; real pricing

differs per model, per direction, and per cache status. Rebuilt with real per-model, per-token-type pricing and verified against an actual provider bill: a session the old meter called ~$25 prices to ~$3.50 — matching the console. Every dollar figure in the app (meter pill, per-conversation spend, usage history) corrected at once.

• The prompt cache was being wasted. Console data from a real session showed only 4% of input

tokens read from cache — nearly the whole bill was cache writes, paying the premium and never collecting the discount. A replay investigation proved the mechanism (a history-trimming step was shifting the message prefix on every call, invalidating the cache each time), and the fix took that session's measured cache reads to the ~85–95% range. Honest saving on that one receipt: about 6× — $0.60 down to roughly $0.10. That's a receipt, not a benchmark; your sessions will vary.

• Some telemetry was dead and nobody knew. Months of usage, zero rows of token history on disk —

the plumbing between the model provider and the storage layer was silently dropping usage data for an entire routing path, including local models. Now fixed, normalized at one boundary, and locked with tests so it can't silently regress. Lesson worth stealing: when a cost surface reads empty, suspect the plumbing before the storage.

Around the meter, the spend-control story rounded out: every conversation permanently carries its own token and dollar totals, the start screen shows a year-view usage tree, a spend circuit-breaker pauses runaway loops — and you can always stop. The send button becomes a stop button mid-run, and the budget pause now has a real "stop here" that keeps the work already done.

The chat header pill now reads tokens · cache-hit % · estimated $ at a glance, with a tripwire that warns if cache churn ever creeps back.

3. Git manners: the agent stops treating your repo as its property (July 21 → 25)

This is the section I'd most want other AI-editor builders to read. The blunt product feedback that kicked it off: the agent treated the entire working tree as its own. Every AI coding tool we've tried does some version of this. YeeYee now doesn't:

• It publishes only what it authored. The agent tracks which files it actually edited, and a push

stages exactly the selection you approve. Files changed outside the chat — by you, by another tool — survive branch swaps intact and appear at push time clearly labeled "changed outside this chat," unchecked by default. The safety-net checkpoints still capture everything (recovery keeps working); publication is deliberate.

• "Will this deploy?" is checked before you push. Born from a real scar: a mechanically-successful

push once shipped a dependency-manifest change without its lockfile, and a production site of ours served a stale build for two days while every signal looked green. Now an always-on, sub-second deployability check runs after every edit, a full local deploy build is one click away, and the push dialog blocks a known-broken push — with a mechanical, zero-AI-tokens one-click lockfile fix, because a deterministic problem should never cost you an agent turn.

• Real rebase, with a safety net. The visual branch canvas already had fork, swap, and merge;

now it has rebase — powered by git's actual rebase machinery underneath, not a hand-rolled replay. The originals stay pinned and recoverable, conflicts reuse the same three-way resolution UI as merge, and a half-finished rebase survives an app restart.

• A real-git health banner. People bounce between editors and terminals all day; none of them talk

to each other. YeeYee now warns — visibly, above the chat — when you're behind your branch's upstream, on a detached HEAD, or sitting on a rebase another tool left mid-flight. It never blocks and never auto-runs anything: the suggested fix is typed into the terminal for you to review and run.

• Pull requests that tell the story. A YeeYee-opened PR now carries what was asked, what the agent

did (a tool-by-tool tally), which files changed, and the full transcript collapsed at the bottom — synthesized from data already in hand, zero extra tokens.

The receipts, because process is the product here: this batch went through adversarial multi-agent review before ship, and those reviews caught 48 real bugs — including a rebase edge case that could have clobbered gitignored files and a stash sequence that could have stranded uncommitted work. Every one was fixed and got a regression test before a user ever touched the feature. Agent-found bugs are cheaper than user-found bugs; that's been true every single week of this project.

4. The preview grows up (July 15 → 19)

The live preview is the heart of the "agent does the work" loop, and it collected a month of street smarts:

• Multi-app repos get a launcher. A repo with several runnable apps now shows you the choices;

swapping the preview target is one click.

• A service is not a broken web page. Previewing a backend service or crawler as if it were a

website once produced a million-token agent no-op — the agent dutifully trying to "fix" a page that was never meant to render. Services are now recognized and presented as services. That single distinction deletes an entire class of wasted spend.

• Port conflicts are diagnosed, not "fixed." Dev servers that auto-hop to a free port are allowed

to; a genuinely stuck port is reported as an environment problem — naming which of your own running apps is holding it — and is never fed to the AI as a code bug to fix. (Previous behavior, confession: it once killed a healthy server one log-line before that server printed its URL.)

• Lighthouse in the chat header. Four real scores — performance, accessibility, best practices,

SEO — live next to your conversation, and any score below 100 is one click from a chat turn that goes and fixes it.

• Smaller but daily-life: the Python notebook's run button is now boringly reliable (plus an explicit

"clear output"), the element picker supports multi-select with color-paired references you can discuss in chat, and the model dropdown grew provider groups, sensible recommendations, and recents — including same-week support for the newest frontier models.

5. The honest-instrument decision: we stopped paying for our own evals (July 16)

The arc post ended with two features "code-complete, awaiting paid evaluation runs." Here's the update, and it's not the one we expected to write: those runs are on hold indefinitely — and that's the honest call.

The measured record earned it. Our per-language tuning lever demonstrably rescues weaker models — that result was real and statistically significant — but on frontier models the same lever was either noise or robustly cost more. More eval cells weren't going to change what we ship; they were going to burn money confirming a curve we could already see.

So the instrument shipped to the people it actually serves: split-testing is now the users' tuning surface. You run splits on your own keys against your own repo, and the same honest statistical gates we built for ourselves — minimum sample floors, bootstrap confidence intervals, replay guards — protect your measurements. A winning configuration gets promoted into your model dropdown for your repo's language group. Firsthand use of a launched product teaches more than another synthetic benchmark cell. The standing rule is unchanged: no headline without a measurement.

Two transparency features shipped in the same spirit:

• The system map — an interactive network diagram of the entire application (38 nodes, 56

connections), now embedded in the app itself, where every node honestly shows its status: shipped, partial, or untested. Most software hides that; we think showing it is the product.

• The Forge door — the live model-training dashboard (the mine → train → evaluate loop from the

arc post) is now a door on the start screen, not a separate tool you have to know about.

What's next

Beta DMGs are going into testers' hands. The newest git surfaces are bench-proven and headed for live click-through. Hard mode is visible on the launch screen behind a "coming soon" gate. And we'll keep publishing the methodology — the metering math, the statistics, the process failures — because the receipts are the point.

Previously: the whole project arc. YeeYee is software developed by dev3lop.com.