Taking action everyday, rehearsing what you already know or learning something new beats someone doing nothing. Keep learning, keep building. AI may write your codes, but you still need to know how it works under the hood.
The standard setup is building an automated pipeline around a golden test set of representative user inputs, then running the old and new versions side by side. You evaluate the results using deterministic checks for formatting and facts, paired with an LLM-as-a-judge using a clear rubric to score subjective quality. To handle non-determinism, you drop the temperature to zero or average scores across multiple runs, comparing aggregate pass rates and direct diffs against your baseline before shipping
AI Engineering Interview Question:
Let's say you're maintaining an LLM feature in production and you want to update the prompt or swap the underlying model: how would you build an evaluation pipeline to feel confident that quality actually improved and you haven't quietly caused regressions, especially given that the outputs are non-deterministic?
The standard way to handle this is to curate a fixed "golden dataset" of maybe 50 to 100 representative tickets that cover your typical edge cases and topics. Whenever you change a prompt, you run it across that whole test set and score the outputs against defined criteria (like factual accuracy and completeness) using an LLM-as-a-judge or rule-based checks. That gives you an aggregate benchmark to prove your new prompt actually improved overall quality before you ship it.
AI Engineer Interview Question:
Let's say you're working on an LLM feature, maybe something like summarizing customer support tickets, and you want to tweak the prompt to improve it. Because LLMs don't always give the exact same answer every time, how would you set up a way to test your changes and be confident that you didn't accidentally make things worse?
In practice, you typically put a lightweight router upfront (like a fast classifier, simple rules based on prompt length, or a tiny model) to decide whether the task needs the cheap or expensive LLM. From there, you wrap those API calls in a fallback pattern, so if the cheaper model times out or throws an error, your system catches it cleanly and retries the prompt with the backup model.
AI Engineer interview question:
Let's say you're designing a feature where you want to balance cost and reliability by sending easy prompts to a fast, cheap model, reserving a bigger, more capable model for tough tasks, and handling things gracefully if an API call fails: walk me through how you'd approach setting up that routing logic.