Notes on AI engineering, LLM agents, and shipping production software.
An Anthropic-co-authored paper builds self-propagating 'mind viruses' that hop between LLM agents. The infection channel is the persistent memory file I already give my own agents.
The figures in these posts aren't drawn by hand. They're generated by bessaviz, a small TikZ/LuaLaTeX library with my brand palette baked in: version-controlled, regenerable, and dark-mode for free. This post is illustrated with it.
My bookkeeping assistant had my personal filing quirks hardcoded into its system prompt. The fix wasn't a bigger prompt: it was storing each learned rule as a pgvector embedding and retrieving it by similarity at registration time.
I built a vault so a skill or an agent could store structured items without me rewriting the domain each time. That meant designing the DRF API for a non-human caller: stable UUIDs, an open metadata field, and a discoverable OpenAPI schema. Then I probed it for idempotency and found I never built any.
GPT-5.6-terra lists 20% below GPT-5.4 on both input and output. I swapped my expense tracker's default to it on that basis, then measured it against real receipts: it cost 51% more per receipt, and it would have returned HTTP 400 on every single photo.
Agents need tests the way code does, but the assertion is fuzzy. Here's the EDD loop I built into ReplayGate: deterministic offline replay that gates the build with real exit codes, an LLM judge that only ever advises, and the honest cost of pinning replay to a hash.
I wrote a benchmark to prove my vault API's eager loading worked, charted it, and published it. Five weeks later I deleted the eager loading from the viewset to watch the benchmark go red. Fifteen tests passed in 4.67 seconds and the benchmark cheerfully printed the same flat line.
An accounting kernel that must never say a word to a user. Every domain failure gets a typed exception and a stable machine code; one adapter table turns that code into localized prose. Here's the hierarchy, the import cycle it caused, the contract check that reported green through a hole, and the bug I found writing this.
Not every page earns a client-side framework. In my expense tracker, HTMX drives the CRUD-heavy pages and React islands power only the analytics dashboard and chat widget. Here's the rule I use to decide which gets which.
A vision model reads the receipt fine, then quietly loses a cent splitting the discount. Here's why I moved the arithmetic out of the model into a small Python function whose shares always sum to the amount paid.
Before I edit a repo I don't grep it, I ask it. codegraph keeps a live SQLite graph of every symbol and edge, served over MCP, and one query returns the verbatim source a dozen greps would have chased. Here's how it changed the way I explore code.
A provider-agnostic layer is the easy part. The recurring cost is keeping the model IDs and capabilities current as GPT-5.6 and Gemini reshuffle underneath you. Here's the churn my adapter absorbed this month, and the three call sites the refresh silently repointed.
OpenAI shipped gpt-transcribe and gpt-live-transcribe and priced the async model below the Whisper endpoint it replaces. I re-ran my own LibriSpeech benchmark against my local pipeline on the same laptop. The API won, by less than the error rate suggests, and the number worth paying for is not the one on the benchmark.
If you want a language model to carry out a plan, write the plan for a machine: XML-tagged structure, atomic find/replace edits, patterns defined once, and a verification checklist baked in.
The day you swipe a card is not the month you're accounting for. Here's how I modelled credit-card billing cycles as a pure function, applied it in one save hook, and used an irreversible migration to stop a future rule change from rewriting the past.
Resetting every user's quota on the 1st sounds like a one-liner. Duplicate executions and month-boundary math say otherwise. Writing this post is also how I found the bug that refilled December's users every single day.
A reliable code generator isn't one giant prompt. Split it into three stages: an LLM parses a request into a validated spec, a deterministic script customizes a template, and a final gate checks the result. Determinism where you can, an LLM only where you must.
OpenAI says its models escaped a sandbox and attacked Hugging Face to cheat an eval. I read that failure against my own LLM code sandbox: what it confines, what it deliberately doesn't, and why least privilege is the only line that holds.
Every LLM provider has its own message shape, token counting, and errors. Here's how to hide all of it behind one Chatter interface, using mixin composition instead of factory boilerplate.
Every page wants its own 1200×630 social card. Instead of designing each one by hand, drive headless Chrome over a parameterized HTML template at build time, then shrink the output ~80% with a PNG8 palette step whose key move is turning dithering off on flat graphics.
When a conversation overflows the context window, dropping the oldest turns throws away meaning. Summarize the middle instead: the pattern every major LLM provider now ships natively, and how the loop works when you build it yourself.
The Django ORM is synchronous; an AsyncWebsocketConsumer is not. database_sync_to_async is the wrapper that bridges them. How Channels' async consumers and channel-layer groups broadcast to every connected client, and where the ORM boundary actually sits.
Storing recipes, bookmarks, journals and groceries behind a single REST surface: a polymorphic Item base, dynamically composed nested serializers, atomic multi-table writes, and the eager-loading that kills the N+1 queries.
You don't need a paid API to transcribe audio. With faster-whisper, int8 quantization, and a little ffmpeg preprocessing you get offline, free transcription. I benchmarked all five model sizes on CPU against LibriSpeech, and the biggest one didn't win.
I benchmarked a tiered LLM safety gate with 800 real API calls: a fast model on the hot path, a larger one for the cases that need reasoning, plus circuit breakers and a caution-biased fallback. The measurements upended my reasons for tiering. On current models the fast and large tiers run at nearly the same speed, so the real payoffs are cost and, more importantly, catching the emergencies the cheap model quietly gets wrong.
A generic assistant can't personalize. Pair a vector store for semantic recall with a persistent working-memory profile, and an agent starts to actually know the user: their categories, budgets, and anomalies.
Résumés, recipes, invoices and receipts all hide structured facts in free-form layouts. Pulling them out reliably means combining a few well-known techniques (layout parsing, heuristics, NER, document-AI models, and a grounded LLM) rather than reaching for one hammer.
Modern sites fingerprint the device and timing, not just navigator.webdriver. Here's how a stealth Selenium setup injects CDP commands, masks automation markers, and persists realistic state to pass real detection suites.
Pulling years of monthly vehicle prices from a flaky legacy ASP site is a resilience problem: checkpoint and resume, handle modal dialogs, retry hard, and land the result as clean columnar data you can actually analyze.
A naive molecular-dynamics loop is O(N²) and dies past a few hundred particles. With cell lists, a cutoff Lennard-Jones potential, velocity-Verlet integration, and reduced units, you can simulate thousands of particles in pure NumPy and watch a gas equilibrate.
A practical look at sandboxing the code a language model writes — the threat model, the isolation options, and a minimal Docker setup you can build on.