Notes on AI engineering, LLM agents, and shipping production software.
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.