Tian Pan
Software Engineer
The CAP Theorem for AI Agents: Choosing Consistency or Availability When Your LLM Is the Bottleneck
When an AI agent's tool call fails or the LLM times out, you face the same tradeoff distributed systems engineers know from the CAP theorem. Most agent frameworks silently choose availability — and pay for it in production.
Chunking Strategy Is the Hidden Load-Bearing Decision in Your RAG Pipeline
The chunk size and boundary strategy you commit to at index time sets a ceiling on your RAG system's quality. Here's how to tune it correctly and catch regressions before they become silent failures.
Communicating AI Limitations Across the Organization: A Framework for Engineering Leaders
Between 70 and 95% of enterprise AI initiatives fail — not because of bad models, but because legal, sales, and ops each build a different mental model of what the system does. A structured framework for engineering leaders to align stakeholders before miscommunication becomes a production crisis.
The Compound Accuracy Problem: Why Your 95% Accurate Agent Fails 40% of the Time
A 10-step agent pipeline where each step is 95% accurate succeeds only 60% of the time. Here's the math behind why, and the architectural patterns that actually bend the failure curve.
Contract Testing for AI Pipelines: Schema-Validated Handoffs Between AI Components
When one AI stage produces structured output consumed by the next, you've created a producer-consumer contract nobody tests. Here's the consumer-driven contract testing approach adapted for probabilistic AI outputs.
Conversation State Is Not a Chat Array: Multi-Turn Session Design for Production
The chat-history-as-array abstraction breaks in predictable ways at production scale. Here is the session design that actually holds up.
Cross-Lingual Hallucination: Why Your LLM Lies More in Languages It Knows Less
LLMs hallucinate 15–35% more in non-English languages, but aggregate benchmarks hide this gap. Here's why it happens, how to measure it, and the production architectures that reduce it.
The Data Flywheel Trap: Why Your Feedback Loop May Be Spinning in Place
The data flywheel sounds like a compounding advantage, but most implementations have at least three leakage points that silently corrupt the training signal. Here's the audit that separates real flywheels from their imitations.
Data Lineage for AI Systems: Tracking the Path from Source to Response
RAG pipelines without attribution metadata leave you blind when a response is wrong. Here are the lightweight span-tagging patterns that capture retrieval provenance and make hallucination debugging systematic.
The Data Quality Ceiling That Prompt Engineering Can't Break Through
Prompt engineering hits a hard ceiling when the underlying data is noisy, stale, or duplicated. Here's how to diagnose data failure vs. model failure and what actually moves the needle.
The Document Is the Attack: Prompt Injection Through Enterprise File Pipelines
Why naive document ingestion pipelines—PDFs, emails, spreadsheets—are rich prompt injection vectors, the specific attack patterns attackers use, and the content provenance architecture that actually defends against them.
EU AI Act Compliance Is an Engineering Problem: The Audit Trail You Have to Ship
High-risk AI systems under the EU AI Act require auditable decision logs, human oversight hooks, and conformity assessments that can't be bolted on post-launch. Here's the data model, logging architecture, and oversight trigger design that make compliance an engineering discipline.