Page 132
12 articlesLLM-Powered Test Generation: Using AI to Find Bugs in Your Software, Not Just Write It
How LLM-powered test generation catches bugs that hand-written suites miss — covering the oracle problem, mutation-guided approaches, hybrid architectures, and CI integration patterns that keep your build deterministic.
LLMs as Universal Protocol Translators: The Middleware Pattern Nobody Planned For
Teams are using LLMs as runtime protocol translators to bridge incompatible APIs and legacy formats. Here's the architecture that makes it safe, the failure modes that make it dangerous, and a decision framework for when it actually makes sense.
Model Merging in Production: Weight Averaging Your Way to a Multi-Task Specialist
A technical deep dive into model merging techniques—weight averaging, SLERP, task arithmetic, TIES, and DARE—covering when merging beats ensembles, common failure modes, and how to deploy merged LLMs in production.
Multimodal RAG in Production: When You Need to Search Images, Audio, and Text Together
A practitioner's guide to multimodal RAG: embedding alignment across modalities, cross-modal reranking strategies, cost and latency tradeoffs, and the failure modes that only surface at production scale.
The On-Call Burden Shift: How AI Features Break Your Incident Response Playbook
AI features introduce failure modes — silent degradation, provider-side changes, prompt injection — that traditional monitoring cannot detect. A practical guide to rebuilding on-call practices for non-deterministic systems.
PII in LLM Pipelines: The Leaks You Don't Know About Until It's Too Late
How personal data silently leaks through prompt templates, context windows, observability tools, and RAG pipelines — and the engineering patterns that actually stop it.
The Plausible Completion Trap: Why Code Agents Produce Convincingly Wrong Code
Code agents produce code that compiles, lints, and looks right but silently does the wrong thing. Here's why the training objective guarantees this, what the data shows, and how to build verification loops that actually catch it.
Prompt Injection Surface Area Mapping: Find Every Attack Vector Before Attackers Do
A practitioner's methodology for enumerating every external data source that reaches your LLM prompt, risk-scoring each injection surface, and applying the right sanitization pattern without breaking model reasoning.
Property-Based Testing for LLM Systems: Invariants That Hold Even When Outputs Don't
Eval datasets tell you whether your LLM passes a fixed set of examples. Property-based testing tells you whether it obeys a contract across the entire input space. Here's how to apply it to non-deterministic systems.
Provider Lock-In Anatomy: The Seven Coupling Points That Make Switching LLM Providers a 6-Month Project
Seven hidden coupling points — from prompt syntax and tool calling schemas to embedding spaces and billing models — explain why switching LLM providers takes months, not days. A practical audit framework for managing lock-in deliberately.
Race Conditions in Concurrent Agent Systems: The Bugs That Look Like Hallucinations
Parallel sub-agents silently corrupt shared state in ways that look exactly like model hallucination. Here's how read-modify-write races work in production agent systems, which distributed systems primitives fix them, and the instrumentation that tells a concurrency bug from a genuine model failure.
Coalesce Before You Call: The LLM Request Batching Pattern That Cuts Costs Without Slowing Users Down
Request coalescing is a layered architecture—in-flight deduplication, exact caching, and semantic batching—that cuts LLM inference costs 40–60% without degrading user experience. Here's how to implement it and where it breaks down.
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.
