Articles / careerinterviewprojects
How to explain your AI project in an interview: a 5-part script
A five-part structure for talking about an AI project in an interview, with a worked example, the follow-up questions to expect and the red flags to avoid.
"Walk me through a project you built" comes up in almost every AI interview. A lot of good projects lose here, because the answer turns into a tour of the stack: "I used LangGraph, then Pinecone, then GPT, then FastAPI." The interviewer learns which libraries you installed. They don't learn whether you can make decisions.
What they want to know is simpler. Did you understand the problem? Did you make choices for reasons? Do you know where your system fails, and how you found out? You can answer all three in about four minutes if you have a structure ready.
This is the structure I use. It has five parts, and each one answers a question the interviewer has but may not ask out loud.
The five parts#
| Part | Time | The question it answers |
|---|---|---|
| 1. Problem | 30 s | Is this a real problem, or a tutorial? |
| 2. Constraints | 30 s | Do you know what made it hard? |
| 3. Design and why | 90 s | Can you make and defend decisions? |
| 4. What broke and how you measured | 60 s | Do you test your own work? |
| 5. What you'd change | 30 s | Can you look at your work critically? |
About four minutes in total. Stop there and let them pick what to dig into. A walk-through that runs ten minutes uses up the time they had planned for follow-ups, and the follow-ups are where you score.
1. Problem: one sentence a non-engineer would understand#
Start with who has the problem and what it costs them. Leave out the technology.
Weak: "I built a multi-agent RAG system with LangGraph." Better: "Job hunting means asking the same few questions over and over: does my resume fit this job, who is hiring, which applications went quiet, and can you draft a follow-up. Each one needs a different kind of system."
If you built it for practice, say so plainly. "I built it to learn multi-agent orchestration on a problem I actually have" is a fine answer. Pretending a portfolio project has users when it doesn't is a trap, because the next question will be about those users.
2. Constraints: what made it hard#
This part is often skipped, and it is where a project starts to sound like engineering. Constraints are things like:
- Data: how much, how messy, how private.
- Cost and latency: free tier, cold starts, per-request budget.
- Risk: can the system do anything that can't be undone?
- Correctness: what happens when it's wrong?
Two or three constraints are enough. Each one should connect to a decision in part 3.
3. Design and why: three decisions, each with its alternative#
Don't list every component. Pick the three decisions that mattered most and, for each, say what you chose, what you rejected and why. The rejected option is what shows you actually decided something.
Use the shape: "I chose X over Y because of constraint Z."
4. What broke and how you measured#
This is the strongest part of any project story, and it's the part candidates are most tempted to leave out. Interviewers know every real system breaks. A candidate who reports no problems either didn't test, or isn't telling them.
Give one or two specific failures. For each: how you noticed it, what the cause was, what you changed, and how you checked the fix. Numbers help, but only real ones. "My eval set had 20 questions and 3 failed on the first run" is better than "accuracy improved significantly".
5. What you'd change#
One or two honest sentences. Choose something you understand now that you didn't at the start. This part shows you can look at your own work from outside, which matters a lot for a senior role.
A worked example: CareerPilot#
Here is the script applied to CareerPilot, a multi-agent job-hunt copilot I built. The full build write-up is in that post. This is the four-minute version.
Problem. "Job hunting is a few repeated questions: does my resume fit this job, who's hiring right now, which applications went quiet, and draft a follow-up to this recruiter. Each needs a different kind of system, so I put them behind one chat box."
Constraints. "Three things shaped it. First, one of the agents writes messages that leave the app, so nothing could be sent without a human approving it. Second, one agent writes SQL from plain English, and that SQL must never be able to change data. Third, it runs on free hosting, so the backend has cold starts of 30 to 60 seconds."
Design and why.
- "Routing is an LLM call, but its output must validate against a Pydantic schema with a fixed list of agent names. If it fails, it retries twice and then raises an error instead of guessing. I chose that over free-text routing because a wrong agent name would otherwise fail silently later."
- "The specialist agents run in parallel through LangGraph's
Send, and their results merge through a reducer. I chose a graph over a single agent with every tool, because each agent then gets a small prompt and only the tools it needs." - "The one agent with side effects only stages a draft. The graph pauses with LangGraph's
interrupt()until the user picks Send, Edit or Cancel. The recipient comes from configuration, never from the model." - "For SQL I used three layers: the prompt asks for SELECT only, a validator rejects anything that isn't a single read-only statement, and in production the database role is read-only. Only the last layer is a real security boundary; the validator is there to fail early with a clear message."
What broke. "Two things worth mentioning. My golden eval set found three bugs on its first run that the unit tests had missed. For example, an off-topic question got answered from unrelated resume chunks, which I fixed with a grounding check. Separately, in production the jobs agent quietly fell back to a fake data source, because the free-tier cold start was slower than my 15-second startup probe. Users would have seen invented companies with no error anywhere. I raised the timeout, added a retry, and learned to log every fallback."
What I'd change. "I'd write the golden eval set before building the second agent, and I'd make every fallback visible from day one."
That takes about four minutes, and each paragraph gives the interviewer something to dig into.
The follow-ups to expect, and how to answer them#
Once you stop, the interviewer will push on whatever sounded weakest or most interesting. These come up again and again.
"Why did you need multiple agents? Couldn't one agent with all the tools do it?" Have a real answer. Good reasons: smaller prompts per task, tools isolated so the SQL agent can't send messages, and parallel execution. It's also fine to say where the split costs you: an extra LLM call for routing, and more moving parts to test.
"How do you know it works?" Describe your evals concretely: what is in the golden set, what each check measures, and what a failure looks like. If your only answer is "I tried it and it looked good", go and build a small eval set before your next interview. Twenty cases is enough to start.
"What happens when the model returns something invalid?" Talk about schemas, retries, and what happens after the last retry. "It raises an error the UI can show" is a good answer. "It usually works" is not.
"What did it cost to run?" Know your rough numbers: tokens per request, which calls are the expensive ones, and what you'd cache. If you only ran it on a free tier, say so and explain what would change at scale.
"What would break at 100 times the traffic?" Pick the real bottleneck. For most LLM apps it's rate limits and cost on the model API, then any synchronous work in the request path. Saying "the database" by reflex without thinking it through is a common miss.
"What would you do differently?" You've already answered this in part 5. Go one level deeper this time.
Red flags interviewers notice#
- A stack tour. Naming ten tools and no decisions.
- "We". If it was a team project, say exactly which part was yours. Interviewers will ask, and an unclear answer reads as not having done it.
- Numbers without a method. "95% accuracy", measured on what, by whom, against which baseline?
- No failures. Covered above. It sounds like you didn't test.
- Claiming users or scale you don't have. Portfolio projects are fine. Inflated ones get found out in one follow-up.
- Not knowing your own code. If you used a template or an AI assistant to write parts of it, make sure you can explain every file you'd show. Some interviewers open the repo during the call and ask about a specific file.
Prepare it once, use it everywhere#
Write the five parts down for your two strongest projects. Read them out loud once with a timer and cut until each is under five minutes. Then write down the five follow-ups you'd least like to be asked, and answer them in writing too.
That's an evening's work, and it covers most of the "tell me about a project" round. The resume line, the LinkedIn post and the README all come from the same five parts, so it's worth having them in one place.