Page 124
12 articlesAgent Memory Garbage Collection: Engineering Strategic Forgetting at Scale
Production agent memory systems degrade silently as stale facts and contradictions accumulate. Generational decay tiers, semantic deduplication, contradiction detection, and adaptive compression form a GC pipeline that keeps long-running agents reliable — with concrete algorithms borrowed from runtime garbage collection.
The AI Code Review Trap: Why Faster Reviews Are Making Your Codebase Worse
AI tools make engineers faster at writing and approving code — but defect escape rates are climbing. Here's the data on automation bias, silent logic failures, and the review protocols that actually catch AI bugs.
The CAP Theorem for AI Agents: Why Your Agent Fails Completely When It Should Degrade Gracefully
Most AI agents fail completely when a single tool goes down — the same consistency-vs-availability tradeoff distributed databases solved decades ago. Here is how to design the partial-availability path.
Cascading Context Corruption: Why One Wrong Fact Derails Your Entire Agent Run
A single hallucinated fact in step 3 of a 25-step agent run can silently corrupt every subsequent conclusion. Learn the three propagation vectors, checkpoint-and-verify patterns, and architectural strategies that prevent cascading context corruption in production agent systems.
Your Code Review Process Is Optimized for the Wrong Failure Mode
AI-generated code shifts defects from typos to architectural drift, hallucinated APIs, and cargo-culted patterns — yet reviewers rubber-stamp it faster. A practical checklist and metrics framework for adapting your review process.
Corpus Curation at Scale: Why Your RAG Quality Ceiling Is Your Document Quality Floor
Most RAG failures aren't model failures—they're data failures. How document quality determines your retrieval ceiling, and what corpus hygiene actually looks like in production.
Data Provenance for AI Systems: Why Tracking Answer Origins Is Now an Engineering Requirement
When your LLM gives a wrong answer in production, can you trace exactly which documents contributed to it? If not, you're already behind. Here's how to build source lineage into AI systems from day one.
Goodhart's Law in Your LLM Eval Suite: When Optimizing the Score Breaks the System
How teams inadvertently game their own LLM evals, why benchmark scores diverge from production quality faster than you expect, and the meta-evaluation practices that keep your eval suite honest.
GPU Scheduling for Mixed LLM Workloads: The Bin-Packing Problem Nobody Solves Well
Serving multiple LLM models on shared GPU clusters wastes 30–50% of available compute. Here's why Kubernetes GPU scheduling fails for LLM inference and what actually works.
The Institutional Knowledge Drain: How AI Agents Absorb Decisions Without Transferring Understanding
When AI agents handle tasks end-to-end, the reasoning that once flowed through human conversation stops flowing. Here's what that costs engineering teams — and concrete patterns to stop the drain before it compounds.
Why Your Database Melts When AI Features Ship: LLM-Aware Connection Pool Design
AI features create bursty, long-running query patterns that exhaust connection pools designed for predictable web traffic. Pool segmentation, admission control, and the release-before-LLM-call pattern prevent AI workloads from starving your core product.
Machine-Readable Project Context: Why Your CLAUDE.md Matters More Than Your Model
Every AI coding tool reads a project-specific markdown file before responding. The quality of that file predicts output quality more reliably than the model behind it — yet most teams write them once, badly, and never update them.
About Tian Pan
I'm Tian Pan, an engineer-founder focused on agentic engineering — building autonomous AI systems and scaling engineering teams. I write practical guides on system design, technical leadership, and shipping with AI agents. Previously an early engineer at Uber, Brex, and IoTeX.
