Videos.

A green test suite did not prove that the final MP4 still matched the approved package. The repair binds the current video path and SHA-256 digest to the validation report.

One behavior, three integration boundaries, 12 application files, and no merge authority: the constraint that kept a real GPT-5.6 Sol refactor narrow enough to review.

The publish gate now requires the reviewed package, story, current video path, and current bytes to agree, stopping stale state or the wrong artifact before release.

A bounded GPT-5.6 Sol refactor inside a real production video system, followed by an independent review that found the missing artifact-provenance guarantee.

Local assistants already record failures, retries, repairs, and corrections. With training events, redaction, quality gates, and evals, those logs can become a disciplined learning loop.

An AI voice pipeline is only useful if it can reject bad takes before they ship. Fish-S2 Plus generates the narration, ClearVoice cleans each slide after the mix, and NIQA plus Audio Flamingo score artifacts, speaker match, and expression so cleanup improves rough audio without sanding the voice flat.

Local small models are the right default for narrow, high-volume AI work: classification, extraction, routing, and rewrites that should not be billed forever. Run them through Ollama, MLX, or vLLM, fine-tune with LoRA when prompting drifts, and escalate only the hard cases to the cloud.

Text and image generation look like the same trick from the outside, but under the hood they are two completely different machines - a language model that writes one token at a time like a typewriter, and an image model that sculpts a picture out of noise.

The most expensive part of an AI agent is usually not the answer - it is everything the agent reads on the way there. Headroom compresses that context before the request leaves your machine and lets the model ask for full detail only when it needs it.

The honest, fast-changing answer to whether an open model running on hardware you own can do genuinely useful agentic work inside a real codebase - what you trade away by renting a cloud frontier model, and what self-hosting buys back.

Quantization is the single most important lever for fitting large models onto hardware you actually own. What a number really is inside a model, how quantization shrinks it, and what genuinely fits in 128 GB of unified memory.

A small box on your desk can now run a whole family of open models at once - and do the one move the cloud quietly will not let you afford: let the models loop on their own outputs. Why raw speed is the wrong scoreboard for local AI.

NVIDIA's Nemotron 3 Ultra is built as the flagship model for long-running agents - planning across steps, calling tools, holding context, and recovering when the first attempt fails. Where Ultra belongs in a stack, and when a leaner model is better.

Joining a gaming laptop with an RTX 4090 and an NVIDIA DGX Spark into a single Kubernetes cluster so they work as one pool of compute - and a from-the-ground-up Kubernetes lesson using that real cluster as the running example.

The slick animations in explainer videos - sliding titles, sweeping arrows, counting numbers - don't need expensive software. A huge number are made in Blender, which is free. From clean flat graphics to full three-dimensional showpieces.

Async processing as a handoff - Django accepts the request, Redis holds the job, and a Celery worker finishes the slow work after the response is already back. Queues, workers, backlogs, retries, and when not to bother.

Why pgvector lets Postgres do vector search itself - a vector column type, distance operators, and IVFFlat vs HNSW indexes - so most projects never need a separate vector database.

LangSmith's agent engine closes the gap between shipped and working - it clusters production failures into named issues, traces each back to the commit that introduced it, and drafts a fix that waits for your approval.

Tavily gives a language model real-time web search in four lines - structured results with a synthesized answer field, search-depth and time-range knobs, and a first-party LangChain tool.

Episode 2: open the actual repo and run all six stages on 115 declassified PDFs — Chroma retriever returns cited answers and a FalkorDB graph agent writes Cypher from plain English.

Episode 1: the architecture of a six-stage RAG pipeline plus a GraphRAG layer in LangChain + LangGraph, built to read 4 GB of declassified UFO files on a single workstation.

Once the Runnable interface clicks, the rest of LangChain — LCEL, LangGraph, tools, retrievers, structured output — becomes predictable instead of surprising.

LangGraph's StateGraph, reducers, conditional edges, and checkpointer run identically against local models - no hosted LLM or API key required.

Twenty precise 3D printing terms - fillet, chamfer, manifold, draft angle, clearance fit - that let you command an AI to design parts that actually print on the first try.

A complete tour of LangChain's five packages - LCEL, LangGraph, retrievers, tools, structured output - assembled into a working RAG application.

Wiring Blender's MCP server and 3MF export into Claude Code or Codex so AI agents can drive a full 3D print workflow end-to-end.

How AI plus CADQuery turns text descriptions into parametric CAD scripts and STL files - and where the workflow quietly breaks.

Every web page is structured data wearing an HTML costume. The four moves under the hood, the three-layer stack, and what AI changed about all of it.

What actually makes a page show up inside ChatGPT, Perplexity, and Google AI Overviews - and how to write for it.

Every local coding agent writes a structured log. Resume, replay, and audit are all downstream of that one file.

Walking through the Pi Mono shared agent stack from inside a real app, not as an abstract architecture diagram.

Hands-on with Fish Speech S2 Pro - what it sounds like, what it costs to run locally, and where it actually wins.

The lesser-known Claude Code tools, what they really do, and which ones changed how I move through a repo.

The architecture under Pi Mono - one harness, many agents - and why that shape keeps showing up in local AI tools.

The three control surfaces that decide what an agent can read, run, and change inside your repo.

What Cursor's retrieval is really doing in a large monorepo, why it drifts, and the small repo changes that pull it back on track.

Codex grew up: cloud tasks, sub-agents, and approvals stitched into one workflow you can actually drive from the CLI.

AGENTS.md, skills, MCP, search, and compaction - the layers Codex uses to narrow a big repo down to a working set.

A plain-English walkthrough of the Codex loop: instructions in, tools and reads, edits out, approvals around it.

What Cursor is doing under the hood - context, retrieval, edits, and the trade-offs that come with the IDE shape.

MCP, demystified. Why it's a capability bus, not a plugin store, and what that changes about how agents reach external tools.

Side-by-side teardown of three terminal coding agents - the loop, the tools, and the parts they each get right.

The case for keeping AI coding in the terminal: tighter loops, smaller context, and tools you already trust.

Inside OpenClaw - a local control plane for routing AI work between models, tools, and approvals on your machine.

ComfyUI from a software engineer's angle - nodes as functions, graphs as programs, and where the real product lives.

Using Bruno to drive local AI APIs - file-based requests, OpenAPI sync, and reviewable diffs instead of throwaway curl.

Wiring a real local AI coding workflow into Neovim - the editor stays the editor, the agent stays in the loop.

Companion to the blog post - reading ADF pipeline and dataset JSON from the Azure CLI to inspect a real factory.

Discovering an ADF instance from the command line - listing pipelines, datasets, and linked services without the portal.

Quick tutorial on driving ChatGPT Codex with diffs you can review, apply, and roll back like any other commit.