Tian Pan
Software Engineer
AI Succession Planning: What Happens When the Team That Knows the Prompts Leaves
When the engineer who wrote your system prompt leaves, the reasoning behind every phrasing decision leaves with them. Here's how to build AI systems that survive personnel changes.
AI User Research: What Users Actually Need Before You Write the First Prompt
Most AI features fail not because the technology is wrong, but because teams asked users what they wanted instead of observing what they actually do. Here's how to run user research that produces reliable behavioral signal before you build.
The Alignment Tax: Measuring the Real Cost of Shipping Safe AI
Every safety layer you add to a production AI system has a measurable cost in latency, tokens, and user friction. Here's how to instrument that cost and make principled tradeoffs.
Ambient AI Architecture: Designing Always-On Agents That Don't Get Disabled
Most ambient AI features get disabled within two weeks of launch — not because the model is bad, but because the interrupt threshold is wrong. Here's the architectural and UX framework that prevents it.
Your Annotation Pipeline Is the Real Bottleneck in Your AI Product
Teams invest in feedback capture UI while the downstream annotation pipeline — schema versioning, IAA scoring, queue prioritization — runs two sprints behind indefinitely. Here's how to fix it.
Annotation Workforce Engineering: Your Labelers Are Production Infrastructure
Most ML teams treat annotation as a procurement problem. It's an infrastructure problem. Here's how to run a labeling operation with the same rigor as production systems.
Annotator Bias in Eval Ground Truth: When Your Labels Are Systematically Steering You Wrong
How annotator selection, demographics, and systematic error patterns corrupt your eval ground truth before training even begins — and the audit methodology to catch it.
API Contracts for Non-Deterministic Services: Versioning When Output Shape Is Stochastic
Traditional API contracts break when services wrap LLMs. Here's how to version, test, and maintain backward compatibility for probabilistic systems.
API Design for AI-Powered Endpoints: Versioning the Unpredictable
When you upgrade an AI model behind your API, the JSON schema stays the same but the tone, refusal behavior, and reasoning style can all shift. Here are the patterns — snapshot pinning, structured outputs, behavior envelopes, and shadow deployments — that keep AI endpoints stable for callers.
Behavioral SLAs for AI-Powered APIs: Writing Contracts for Non-Deterministic Outputs
When your API wraps an LLM, traditional SLAs break down. Learn how to define behavioral contracts — format guarantees, refusal rates, latency p95, hallucination budgets — and how to version and communicate behavioral changes without breaking your consumers.
Browser-Native LLM Inference: The WebGPU Engineering You Didn't Know You Needed
Running LLMs directly in the browser via WebGPU changes your entire application architecture. Here's what the capability ceiling actually looks like, and when hybrid routing beats a pure cloud approach.
Coding Agents in the Monorepo: Why Context Windows and 50-Service Repos Don't Mix
Coding agents hit a hard wall in large monorepos: the relevant code for any cross-service change spans more packages than fit in any context window. Here's what actually works.