Some weeks feel like progress because you shipped something obvious. Other weeks feel like progress because you finally stop doing routine things the hard way.

This was mostly the second kind.

1. We were wasting tokens because we hadn’t scripted enough

The big surprise this week was not that AI usage costs money. It was where the burn was actually coming from.

It turned out the main OpenAI usage wasn’t the Morning Brief. The heavier spend was coming from recurring cron jobs and automation loops: market-data refreshes, Mission Control state work, Mets ticket lookups, FX monitoring, and cron health checks. Once we actually traced the usage, the fix became obvious: stop treating repetitive machine work like a chat problem.

So we started moving the expensive stuff off the paid models, shifted a bunch of jobs to the free preview of Gemini Flash, reduced refresh cadence on noisy tasks and replaced agent-heavy jobs with deterministic scripts where possible.

That sounds obvious in hindsight, which is usually how you know you learned something real.

2. Thin wrappers beat clever agent loops

The best example was a price ticket refresh.

Instead of repeatedly paying an agent to rediscover the same workflow, we replaced it with a scripted pipeline:

• read the source sheet via Google service account
• query public search results directly
• extract prices
• write state to disk
• optionally rebuild the display page

Then the cron job became a thin wrapper around a script.

That is a better pattern almost everywhere:

• easier to debug
• cheaper to run
• easier to rerun manually
• easier to version control
• less dependent on model mood swings

The broader lesson: agents are great for figuring out a workflow, but scripts are better for repeating one.

3. Service accounts are boring, which is exactly why they’re good

We finally stopped pretending old Google OAuth notes were still the right path for automation.

The rule now is simple: for Docs, Drive, Sheets, and shared Calendar work, use the Google service account first and treat old OAuth paths as fallback-only or effectively dead for this workflow.

This is not exciting. That’s the point.

A lot of operational pain comes from trying to preserve a “flexible” auth story long after one path has clearly become more reliable than the others.

4. Remote backtests should be a workflow, not an improvisation

We also spent a lot of time turning backtesting from a weird artisanal ritual into something repeatable.

This led to a new skill and script-driven deploy flow that can:

• publish a self-contained Linux binary
• stage a run bundle with exact configs
• sync it to a remote host
• launch a headless run
• fetch logs back afterward

That matters because optimization work becomes expensive in a different way when every test run requires you to rebuild context in your head.

If you want to run a dozen parameter variations, you need a workflow that treats each run as a reproducible artifact, not a memory exercise.

5. Remote execution strips away comforting illusions

Running locally hides a lot.

There’s a UI. There’s scrolling output. There’s context in your head. There are half-working side effects that make a program feel alive even when it’s actually sloppy.

Remote headless execution is much meaner.

That’s good.

As soon as we pushed the backtest to a remote box, a whole series of problems stopped being theoretical:

• config shape mistakes
• silent mode/branch mismatches
• pre-run assumptions that broke
• native baggage that didn’t belong in backtesting
• lifecycle bugs
• end-of-run persistence issues

In other words, the remote run did not create those bugs. It simply removed the local theater that had been hiding them.

6. Operational clarity is a force multiplier

A lot of the week’s progress came from doing boring, clarifying work:

• documenting script locations
• putting run artifacts in separate directories
• using consistent remote naming
• moving experimental configs into a dev repo instead of polluting prod
• packaging skills so the next run starts from a procedure, not a memory

None of this is glamorous.

All of it compounds.

The real theme

If there was a theme this week, it was this:

Stop paying intelligence tax on repeatable work.

Use judgment to discover the workflow. Then capture it. Then script it. Then version it. Then run it without needing to be clever again.

That applies to cron jobs, docs automation, backtest deployment, and probably most of the rest of the stack, too.

The nice thing about learning this the hard way is that, with any luck, we only have to learn it once.

---