Learning in public
Notes, tutorials, and honest reflections from the journey into AI engineering. Every post, newest first.
Your AI Coding History Is a Dataset. Here's How I'd Actually Use It.
The ai-data-extractor project can pull your entire Claude Code, Cursor, and Cline chat history into structured data. That's interesting. What you do with it afterward is where things get genuinely useful.
The "AI Safety Pact" Is a Cartel in a Lab Coat
When the CEOs of OpenAI, Anthropic, and Google DeepMind agreed to slow AI development for "safety," skeptics didn't have to look hard for the ulterior motive. This smells less like a safety pause and more like incumbents pulling up the ladder.
SparkDash: I Gave a 320B Model a Spec and Pointed It at the Server Serving It
GLM-5.3-Flash, 320B parameters split across two DGX Sparks over a ConnectX-7 cable, built its own monitoring dashboard in 44 minutes. The scorecard was written before the session: what it got right, what broke, and whether the fixes went to the cause.
320B on Two Sparks: What It Actually Takes to Run a Mixture-of-Experts Model Across a Home Cluster
I bridged two NVIDIA DGX Sparks, loaded a 320B open-weights MoE model across both, and wired the endpoint into GitHub Copilot Chat. Every step, every error, and every number, from cable to first correct answer.
Engineering Patterns Beat Model Power: What the Google AI Agents Challenge Actually Proved
Google's AI Agents Challenge surfaced something most people building multi-agent systems already suspect but rarely say out loud: the model isn't the bottleneck. The architecture is.
DriftWatch, measured: what a logistic regression, a coin flip, and a 32-second cold start taught me about ML systems
Six phases, 21 days, and every number measured. The wrap-up on DriftWatch: what it produced, what it cost, what broke, and what's still not done.
The Four Patterns That Separate Toy Agents from Production Agents
Google's AI Agents Challenge revealed something most tutorials skip: what set the winning multi-agent systems apart was software engineering, not model choice. Four patterns kept showing up in the report, and none of them is an AI problem.
The Model Was 20%: DriftWatch, Part 6
Six phases, one thesis: the model is the small part. DriftWatch is done. This post has every number I measured, eight lessons each pinned to something that happened, and what the dashboard proved by being a page instead of a second app.
The Monitor Caught It. The Loop Answered It. A Human Said Yes. — DriftWatch, Part 5
DriftWatch's drift phase is the one the whole project was built for. A real regime change dropped the champion model to ROC-AUC 0.50, the retrain loop brought a challenger back to 0.99, a screenshot exposed two bugs on the way, and a human still approves the promotion.
Four Failures, One Green Run, and the Teardown That Held Every Time
DriftWatch Phase 4 build log: how enterprise DevOps experience, not ML theory, solved secretless CI/CD, identity scoping, and a managed endpoint that had to prove it worked before it was allowed to disappear.
Raw Cycles In, Probability Out: DriftWatch, Part 3
Phase 3 of DriftWatch is a FastAPI endpoint that accepts raw sensor cycles, computes features from the same code training used, and refuses to answer if it cannot write the prediction down. One decision drives all of it.
Fifty Trials Couldn't Beat Logistic Regression: DriftWatch Part 2
Phase 2 of DriftWatch covered training, MLflow tracking, and model registration in Azure ML. It ended with a surprise: a scaled logistic regression beat XGBoost, including XGBoost after 50 Optuna tuning trials, on engines none of the models had seen.
Data Quarantine, Label Design, and the Phase Where You Fool Yourself: DriftWatch Part 1
DriftWatch Phase 1 had no model in it. It was still the phase where the assumptions that wreck ML projects get made, or don't: label leakage, contaminated holdouts, feature code that drifts from serving. I treated all of it as infrastructure work.
Kiro Crew and the Case for Asynchronous Agents: What AWS Got Right (and What You Still Have to Wire Up)
AWS open-sourced Kiro Crew to run multiple coding agents across sessions and tasks asynchronously. The architectural bet underneath, async by default, matters more than the feature list, and it comes with a bill for durable state that AWS doesn't pay for you.
FrontierAgent Is Interesting. The Agent Team Mode Is the Part Worth Studying.
FrontierAgent just open-sourced a multi-agent framework with ReAct and Agent Team modes baked in. I read the architecture with AgentReview fresh in my head and wrote up the questions I'd want answered before trusting the team mode.
I Built a Twitter Bot Detector in 2022. I Finally Evaluated It Honestly in 2026.
A look back at the Python NLP pipeline I built in 2022: sentiment analysis, XGBoost bot detection, and the evaluation protocol I should have written four years ago.
DriftWatch, Post 0: The Setup Weekend That Wasn't Boring
DriftWatch is my third public AI engineering project, and it exists to prove one thing: the model is maybe 20% of an ML system. Phase 0 was supposed to be the boring setup weekend. It was not.
Model Routing Is an Infrastructure Problem, Not a Prompt Problem
Google Cloud API Gateway's new model routing feature is getting framed as a developer convenience, but what it's really solving is a production infrastructure problem that anyone running multi-model AI workloads has already hit the hard way.
MCP Goes Stateless: What the 2026-07-28 Spec Actually Changes for Agent Infrastructure
The 2026-07-28 MCP spec drops stateful session management entirely. I fought the old session model while building AgentReview's MCP server, so this change matters to me: MCP servers can finally scale like any other stateless HTTP service.
Three AI Agents Reviewed the Same Pull Request (Here's What I Measured)
AgentReview shipped. Three specialized agents reviewed 8 seeded PRs with 18 planted bugs and came back with 100% precision, 17/18 recall, and a cost of $0.068 per review. The one miss is written up honestly in the README.
AgentReview Phase 5: Measuring My Own Agents, and Why Precision Needs a Human
Recall is easy to measure when you plant the bugs yourself. Precision is the metric that fights back. It took 45 manual judgments, a scoring worksheet, and a budget guard wired to every token cap before I trusted these numbers.
AgentReview Phase 4: Fan-Out Is Easy. Synthesis Is the Hard Part.
Getting three agents to run concurrently took an afternoon. Merging their findings without losing signal took real design work, and the approach that survived pairs LLM judgment with plain deterministic code.
AgentReview Phase 3: Three Agents, One Base Class, and Why Lane Discipline Is an Engineering Problem
Once the review pipeline moved into a shared base class, the Security Agent came together in under a day and the Docs Agent went even faster. The proof: 55 tests, 15 committed sample reviews, and a security agent that stays quiet on all four non-security diffs.
AgentReview Phase 2: One Real Agent, Real Tools, and Every Honest Mistake Along the Way
I built a C# Quality Agent that runs a PR diff through both Roslyn and Claude, then merges the results into one schema-locked findings list. Along the way I dealt with deduplication headaches, hallucinated resolution errors, undocumented MCP headers, and a fresh reminder that cost guardrails belong in code.
AgentReview Phase 1: Build the MCP Server First, Ask Questions Later
Before writing a single agent I built the tooling layer: an MCP server in C#/.NET wrapping Roslyn and Semgrep. Building in that order taught me plenty about scanner blind spots, protocol hygiene, and why LLM reasoning belongs on top of static analysis instead of beside it.
Microsoft's Three-Layer LLM Routing Architecture: What It Gets Right (and What You Still Have to Figure Out Yourself)
Microsoft's reference architecture for routing AI agent traffic on AKS splits the problem into three clean layers. I've built and run AI services on Azure in production, so I went through it looking for what holds up and what it leaves you to solve on your own.
DocQuery Phase 4: Shipping a Public RAG Demo That Doesn't Lie About You
DocQuery left my laptop. Turning a local RAG experiment into the live public Interview Vondray demo meant patching an SDK bug on the wire, chasing down an empty-answer mystery, and learning why corpus curation is a security decision.
DocQuery Phase 3: The UX Layer That Makes a RAG Pipeline Feel Real
Streaming citations, live provider switching, and a side-by-side AI race mode. Phase 3 took DocQuery from a working pipeline to something that feels good to use.
DocQuery Phase 2: Benchmarking Three AI Stacks So You Don't Have To
I made DocQuery's entire AI stack swappable with a single config value, then raced a MacBook, an NVIDIA DGX Spark, and Azure against each other. The results overturned most of my assumptions about fast and cheap in local versus cloud inference.
MCP Is the Real Story Behind AI Video Editors
A wave of AI video tools now list MCP support as a headline feature. The interesting part is the protocol underneath, because it's going to show up in a lot more places than video editing.
DocQuery Phase 1: Building a Local RAG Pipeline in .NET (and the War Stories Nobody Warns You About)
I built a fully local RAG app in .NET 10 with Ollama and ChromaDB: upload documents, ask questions, get cited answers. This post covers the architecture, the decisions behind it, and the problems I hit that no tutorial bothers to mention.
AI Agents That Manage Kubernetes: What SRE AgenticOps Actually Looks Like in Practice
AI-powered SRE agents for Kubernetes are picking up steam fast. I dug into what they can do today, where they fall short, and how much of your infrastructure you should let them touch.
Apple Chose Google Cloud Over AWS and Azure (What Does That Actually Mean?)
Apple just ran Private Cloud Compute on Google Cloud for the first time, on NVIDIA Blackwell GPUs with dual-vendor attestation. The architecture choices behind that move say a lot about where confidential computing is headed.
First Post: What This Blog Is About and Why I'm Writing It
I'm Vondray Sanford, a software engineer with seven-plus years in enterprise systems. This blog is where I write up what I'm building and learning across .NET, AI engineering, and the infrastructure that keeps it all running.