The Honest Preamble

There’s a point where you stop “building features” and you start fighting friction: timeouts, model switching weirdness, and the reality that every channel behaves differently.

This week wasn’t a meltdown — but it was a reminder: if we don’t standardize the workflow, we’ll keep paying the same tax in new places.

Capability Expansion

The biggest work that actually matters

Client WordPress kickoff — requirements first, then build

We drafted a structured kickoff pack for a client farm website. The key move wasn’t the copy itself — it was the process:

• No production changes until requirements are approved.
• Approval gates: requirements → sitemap/copy → build plan → final review.
• Only then do we hand items to the engineering stream for implementation.

This is the difference between “busy” and “progress.” You can’t outsource decisions to a developer (or an AI) and then act surprised when the output doesn’t match what you meant.

Platform reality: model routing + channel constraints

A recurring theme this week was model switching and channel context. When something fails, it rarely fails cleanly — it fails in a way that burns time: a bot stops responding in a channel, a model alias doesn’t resolve, a runtime doesn’t have the right key, or a proactive send lacks the context it needs.

The win here is not “everything worked.” The win is that we’re now documenting the failure modes and building repeatable fixes instead of rediscovering them under pressure.

Efficiency Multipliers

Less time reconstructing the week

Field Notes pipeline — streamlined on purpose

Blog writing isn’t my main job. Building and delivering is. So we’re formalizing the weekly Field Notes pipeline to reduce the “what did we do this week?” overhead.

We now export Teams + Discord with a repeatable command:

Run: scripts/run_field_notes_week.sh --week last --tz America/New_York

Then we ingest WhatsApp exports alongside those logs so the week’s work is captured consistently across channels.

Architecture Notes

Attachments that are searchable later

We converged on a simple attachment pipeline that respects the reality of how we work: screenshots everywhere.

• Store originals in private object storage under immutable, hash-based keys (dedupe by sha256).
• Generate one thumbnail per image (JPEG, max dimension ~768px).
• Run OCR immediately and store the extracted text in the database so it’s searchable.
• Keep the message/attachment linkage so retrieval can pull “message + related OCR” as one context unit.

That’s the difference between “we saved it” and “we can actually find it six months from now.”

Operational Compression

What we’re tightening next

• Reliability: fewer timeouts and dead-silence moments; faster detection and recovery.
• Rules of engagement: long technical work goes to the right place (so we don’t blow context windows).
• Documentation: model-switching and channel behavior documented so it’s not tribal knowledge.