Q: How would you design an AI agent that books meetings on behalf of a user?

Agent architecture : LLM core with tool use enabled (Claude tool use / OpenAI function calling) Tool set (narrow, well-typed): list_calendar_availability(user, date_range) → free_slots get_contact(name) → email propose_meeting_times(participants, duration) → slots[] send_invite(participants, time, title, agenda) → confirmation Conversation loop : user request → LLM plans → calls tool → result → next decision → eventually confirms with user Stop conditions : confirmation sent OR user denies OR max iterations reached Safety + reliability layers</str

Q: Explain self-attention. Why is it better than RNNs for sequence modeling?

What self-attention does : for each token, compute a weighted average of all other tokens, where weights come from how relevant each token is to the current one. Each token gets a context-aware representation built from the whole sequence. Mechanically : project each token into Query (Q), Key (K), Value (V) vectors. Attention scores = softmax(QK^T / √d_k) · V. The √d_k scaling prevents large dot products from collapsing softmax to one-hot. Why better than RNNs : Parallelizable — RNNs process tokens sequentially (can't parallelize across timesteps). Attention processes all tokens simultaneously → GPUs work efficiently. Long-range dependencies — RNNs forget early tokens by

Q: Describe a time when you raised an ethical concern about an AI feature.

This question is hard because most candidates either: Have never raised one (telling answer) Tell a sanitized story where they raised it and everyone agreed (unrealistic) What good answers have : A real situation where the right answer wasn't obvious You named the concern specifically (not just "I felt uncomfortable") You took action that was thoughtful (not just "I refused") Outcome reflects realistic tradeoffs (not always a clean win) Structure : The situation — what was being built, what was the concern How you raised it — to whom, what evidence, what proposal What changed</s

Q: Tell me about an AI feature you shipped that failed to meet expectations. What happened?

What interviewers want : honest accountability, clear metrics, structured learning — not blame-shifting to "the model wasn't ready yet." What good answers have : A specific feature and specific failure (adoption, quality, cost, latency — quantified) Your role in the decision to ship What you did after launch, not just that it failed A change you made that stuck (eval, rollback, scope cut, kill) Structure : Context — user problem, what we shipped, success criteria we agreed on What went wrong — leading indicator first, then lagging (CSAT, retention, support tickets) Your resp

Q: Tell me about a time you disagreed with your team about a technical decision.

What good answers have in common : A real disagreement, not a manufactured one You showed your reasoning, listened to theirs You either changed your mind based on evidence OR persuaded them with evidence Outcome reflected the better choice, not the louder voice What to avoid : "I was right and they were wrong" — even if true, this signals you might be hard to work with "We compromised" without specifics — vague "I escalated to my manager" — sometimes correct but usually a last resort Structure : The decision and stakes (what were we choosing, why did it matter) Your position + their position</str

Q: Tell me about the hardest technical problem you've solved.

Use the STAR-but-tighter structure : Situation (1-2 sentences): what context, what scale, what stakes Task (1 sentence): what you were specifically responsible for What made it hard (2-3 sentences): be honest about the difficulty — was it ambiguous? Was the easy approach broken? Was it cross-team? What you tried first (1-2 sentences): show your process. What was your initial hypothesis? Why did it fail or partially work? What actually worked (3-4 sentences): the solution + why it worked + what it cost What you'd do differently (1 sentence): self-aware reflection signals seniority Pick a probl

Q: How do you keep up with AI when the field moves so fast?

Generic answers fail this . "I read papers" / "I follow Twitter" doesn't differentiate. What works: specifics + a deliberate filter. Structure your answer : What you don't try to keep up with — being honest about filtering shows maturity. "I don't try to read every model release; I track architectural shifts and let products mature before evaluating them." What you do read / follow — name 3-5 specific sources, ideally with reasoning How you turn reading into knowledge — what's your loop? Strong sources to actually name (pick the ones you actually use): Papers : ArXiv (specific Slack/Discord channels that cura

Question 1

How do you decide which tools to give an AI agent, and how many is too many?

Accepted Answer

Tool selection is API design for a non-deterministic caller. Optimize for correct selection, safe execution, and debuggability — not maximal capability.

Principles for which tools to expose:

Task-shaped, not API-shaped — search_orders(customer_id, status) beats separate get_user, list_orders, filter_orders the model must chain blindly
Read before write — separate discovery tools from mutating tools; require a read confirmation step before destructive actions
Idempotent mutators — cancel_order(order_id, idempotency_key) with server-side dedupe
No escape hatches — avoid generic

Question 2

How would you design an AI agent that books meetings on behalf of a user?

Accepted Answer

Agent architecture:

LLM core with tool use enabled (Claude tool use / OpenAI function calling)
Tool set (narrow, well-typed):
- list_calendar_availability(user, date_range) → free_slots
- get_contact(name) → email
- propose_meeting_times(participants, duration) → slots[]
- send_invite(participants, time, title, agenda) → confirmation
Conversation loop: user request → LLM plans → calls tool → result → next decision → eventually confirms with user
Stop conditions: confirmation sent OR user denies OR max iterations reached

Safety + reliability layers

Question 3

Explain self-attention. Why is it better than RNNs for sequence modeling?

Accepted Answer

What self-attention does: for each token, compute a weighted average of all other tokens, where weights come from how relevant each token is to the current one. Each token gets a context-aware representation built from the whole sequence.

Mechanically: project each token into Query (Q), Key (K), Value (V) vectors. Attention scores = softmax(QK^T / √d_k) · V. The √d_k scaling prevents large dot products from collapsing softmax to one-hot.

Why better than RNNs:

Parallelizable — RNNs process tokens sequentially (can't parallelize across timesteps). Attention processes all tokens simultaneously → GPUs work efficiently.
Long-range dependencies — RNNs forget early tokens by

Question 4

Describe a time when you raised an ethical concern about an AI feature.

Accepted Answer

This question is hard because most candidates either:

Have never raised one (telling answer)
Tell a sanitized story where they raised it and everyone agreed (unrealistic)

What good answers have:

A real situation where the right answer wasn't obvious
You named the concern specifically (not just "I felt uncomfortable")
You took action that was thoughtful (not just "I refused")
Outcome reflects realistic tradeoffs (not always a clean win)

Structure:

The situation — what was being built, what was the concern
How you raised it — to whom, what evidence, what proposal
What changed

Question 5

Tell me about an AI feature you shipped that failed to meet expectations. What happened?

Accepted Answer

What interviewers want: honest accountability, clear metrics, structured learning — not blame-shifting to "the model wasn't ready yet."

What good answers have:

A specific feature and specific failure (adoption, quality, cost, latency — quantified)
Your role in the decision to ship
What you did after launch, not just that it failed
A change you made that stuck (eval, rollback, scope cut, kill)

Structure:

Context — user problem, what we shipped, success criteria we agreed on
What went wrong — leading indicator first, then lagging (CSAT, retention, support tickets)
Your resp

Question 6

Tell me about a time you disagreed with your team about a technical decision.

Accepted Answer

What good answers have in common:

A real disagreement, not a manufactured one
You showed your reasoning, listened to theirs
You either changed your mind based on evidence OR persuaded them with evidence
Outcome reflected the better choice, not the louder voice

What to avoid:

"I was right and they were wrong" — even if true, this signals you might be hard to work with
"We compromised" without specifics — vague
"I escalated to my manager" — sometimes correct but usually a last resort

Structure:

The decision and stakes (what were we choosing, why did it matter)
Your position + their position

Question 7

Tell me about the hardest technical problem you've solved.

Accepted Answer

Use the STAR-but-tighter structure:

Situation (1-2 sentences): what context, what scale, what stakes
Task (1 sentence): what you were specifically responsible for
What made it hard (2-3 sentences): be honest about the difficulty — was it ambiguous? Was the easy approach broken? Was it cross-team?
What you tried first (1-2 sentences): show your process. What was your initial hypothesis? Why did it fail or partially work?
What actually worked (3-4 sentences): the solution + why it worked + what it cost
What you'd do differently (1 sentence): self-aware reflection signals seniority

Pick a probl

Question 8

Tell me about shipping an AI feature when you had limited or messy data. What did you do?

Accepted Answer

This question tests whether you can ship responsibly with uncertainty — not whether you waited for a mythical clean dataset.

What good answers include:

Honest assessment of what data you had vs needed
Constraints named upfront (label budget, cold start, privacy limits)
Concrete mitigations: weak supervision, synthetic data, human review, narrow scope
Clear good-enough bar and how you measured it
Plan to improve with production signal

Structure:

Feature and data gap — what was missing or messy
Risk if you shipped wrong — user impact, not model F1 in a vacuum
Mitig

Question 9

Describe a time a stakeholder pushed back on your AI approach. How did you handle it?

Accepted Answer

Strong answers show empathy for the stakeholder's constraint, evidence over jargon, and a path forward — not winning the argument in one meeting.

Common pushback types (name yours explicitly):

Timeline: "Can we skip evals and ship for the conference?"
Scope: "Why not fine-tune instead of this RAG complexity?"
Risk: Legal/compliance blocking customer-facing LLM
Cost: Finance questioning $40K/month inference bill
Hype: Exec wants autonomous agent v1 with no human review

Structure:

Stakeholder and stake — who, what they cared about (revenue, risk, reputation

Question 10

How do you keep up with AI when the field moves so fast?

Accepted Answer

Generic answers fail this. "I read papers" / "I follow Twitter" doesn't differentiate. What works: specifics + a deliberate filter.

Structure your answer:

What you don't try to keep up with — being honest about filtering shows maturity. "I don't try to read every model release; I track architectural shifts and let products mature before evaluating them."
What you do read / follow — name 3-5 specific sources, ideally with reasoning
How you turn reading into knowledge — what's your loop?

Strong sources to actually name (pick the ones you actually use):

Papers: ArXiv (specific Slack/Discord channels that cura

Question 11

Why do you want to work in AI?

Accepted Answer

What good answers have in common:

Specific concrete moment ("the first time I…") — anchors authenticity
A working hypothesis about what's interesting / unsolved
Connection to your prior work or skills

What to avoid:

"AI is the future" / "I want to be on the cutting edge" — generic
Reciting industry stats — interviewers can do that themselves
Pretending you've always known — most people had a specific gateway

Template:

The specific moment (1-2 sentences): "When I first built [X] and saw [Y], I realized…"
The hook that kept you (1-2 sentences): "What pulls me is [specific unsolved problem or ang

Question 12

Explain the bias-variance tradeoff. How do you diagnose which is hurting your model?

Accepted Answer

Definitions: bias is error from oversimplifying (model can't capture the pattern); variance is error from being too sensitive to the training data (model captures noise as signal). Total error = bias² + variance + irreducible noise.

How to diagnose:

High bias (underfitting): train and test error are both high and roughly equal. Model can't even fit the training data. Fix: more capacity (deeper network, more features, less regularization).
High variance (overfitting): train error is low, test error is much higher. Big gap. Fix: more data, regularization (L1/L2, dropout), simpler model, early stopping.

A working answer mentions: learning curves are the diagnostic

Question 13

Write code to evaluate a binary classifier and produce all the metrics that matter.

Accepted Answer

import numpy as np
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    roc_auc_score,
    average_precision_score,
    confusion_matrix,
    classification_report,
    precision_recall_curve,
)

def evaluate_binary_classifier(y_true, y_pred_proba, threshold=0.5):
    """
    y_true: (n,) — true labels (0 or 1)
    y_pred_proba: (n,) — predicted probability of class 1
    threshold: decision threshold (default 0.5)
    """
    y_pred = (y_pred_proba >= threshold).astype(int)

    # Threshold-dependent metrics
    metrics = {
        "accuracy": accuracy_score(y_true, y_pred),
        "precision": precision_score(y_true, y_pred, zero_division=0),
        "recall": recall_score(y_true, y_pred, zero_divis

Question 14

Implement scaled dot-product attention in NumPy (or PyTorch).

Accepted Answer

NumPy version:

import numpy as np

def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)  # numerical stability
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)

def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q: (..., seq_q, d_k)
    K: (..., seq_k, d_k)
    V: (..., seq_k, d_v)
    mask: (..., seq_q, seq_k) — True for positions to mask out
    Returns: (..., seq_q, d_v)
    """
    d_k = Q.shape[-1]

    # 1. Compute attention scores
    scores = Q @ K.swapaxes(-1, -2)  # (..., seq_q, seq_k)

    # 2. Scale by sqrt(d_k)
    scores = scores / np.sqrt(d_k)

    # 3. Apply mask (set masked positions to -inf so softmax gives 0)
    if mask is not None:
        scores = np.where(mask, -

Question 15

Look at this code snippet — what's wrong?

Accepted Answer

The code (typical):

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Scale features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Split
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Train + evaluate
model.fit(X_train, y_train)
score = model.score(X_test, y_test)

The bug: scaler.fit_transform(X) uses statistics from the entire dataset, including test data, to scale features. The test set's mean and variance leaked into the training pipeline. Test scores are optimistically biased.

Fix: fit the scaler on training data only.

Question 16

Why do we use cross-entropy loss for classification instead of MSE?

Accepted Answer

Short answer: MSE with sigmoid/softmax has near-zero gradients when predictions are very wrong — exactly when you want the strongest learning signal.

Mechanically:

With MSE + sigmoid, the loss is (σ(z) - y)². The gradient through sigmoid is σ(z)(1 - σ(z)), which approaches 0 when σ(z) is near 0 or 1. So if the model predicts 0.99 for a class that should be 0, the gradient is tiny.
With cross-entropy + sigmoid, the σ' term cancels out algebraically. Gradient becomes simply σ(z) - y. Big error → big gradient. Convex with respect to z.

Probabilistic interpretation:

Cross-entropy is the negative log-l

Question 17

How would you build an evaluation suite for an LLM-powered feature?

Accepted Answer

Three categories of cases — aim for 30-50 total to start:

Happy path / sanity (10-15) — basic correct cases. Catches regressions.
Real-world hard (10-20) — actual user inputs that are tricky. Measures capability.
Adversarial / failure modes (10-15) — prompt injection, edge cases, ambiguous inputs. Measures safety + robustness.

Evaluation methods by task type:

Task	Method
Structured output	JSON schema validation + field-level checks
Classification	Accuracy / F1 against gold labels
Extraction	Token-leve

Question 18

You're building a fraud detection model where 0.1% of transactions are fraud. Why is accuracy a bad metric and what should you use?

Accepted Answer

Why accuracy fails: a model that predicts "not fraud" for every transaction achieves 99.9% accuracy. Useless.

What to use instead (in order of usefulness here):

Precision-recall — not ROC-AUC. For severe imbalance, ROC-AUC is misleadingly optimistic because the negative class dominates the FP rate denominator.
PR-AUC — area under precision-recall curve. The right summary metric for imbalanced classification.
F1 at a chosen threshold — useful but hides the precision-recall tradeoff.
Recall at a fixed precision (e.g. "recall at 95% precision") — directly addresses the business: "how much fraud do we catch while keeping false positives tolerab

Question 19

When does classical ML with feature engineering beat deep learning?

Accepted Answer

Tabular data with limited samples (< ~100K rows): XGBoost, LightGBM, and CatBoost reliably beat deep learning. This is well-established on Kaggle leaderboards and in industry benchmarks. Tree-based models handle mixed types, missing values, and non-linear interactions natively.

When interpretability matters: linear models, logistic regression, decision trees give you per-feature contributions. SHAP works with anything but is more meaningful on simpler models.

When latency budgets are tight (sub-millisecond): a logistic regression or tree ensemble can serve in microseconds. Deep models need GPU/TPU and have higher serving costs.

When you have strong domain features: in fraud, finance, healthcare

Question 20

What's the difference between full fine-tuning, LoRA, and instruction tuning?

Accepted Answer

Full fine-tuning: update all model parameters. Most powerful, most expensive (memory + compute), highest risk of catastrophic forgetting. Rare for modern LLMs — typically only large labs do this on smaller models.

LoRA (Low-Rank Adaptation): freeze the base model, train small "adapter" matrices (typically <1% of base parameter count) that get added to specific layers (attention projections usually). Modern default.

Benefits: cheap (single GPU OK), fast (minutes to hours), reversible (toggle adapter on/off), storable (~tens of MB per adapter), can serve many adapters from one base model.
QLoRA quantizes the base model to 4-bit during training — runs on consumer hardware.

AI interview questions with answers that actually land

AI Job Roles Explained

Skills for an AI Engineer

The AI Interview Process

Break Into AI from Scratch

Interview Prep Checklist

Interview Prep Roadmap (4 weeks)

Drill with an AI interviewer