Skip to content
Back to all posts

November 9, 2026

AI-Assisted Interviews: You Steer, Not the AI

I've been interviewing recently, and a couple of the rounds were in a format I hadn't done before: live, AI-assisted interviews. You share your screen, you get a problem, and you're allowed to use an AI coding tool the whole time. I used Claude Code. They told me upfront they didn't care which tool I picked.

My first reaction was honestly something like "oh nice, easy mode." That lasted about ten minutes into my first practice session. It turns out these interviews are hard, just in a different way than the old ones. They're not testing whether you can write the code. They're testing whether you can stay in charge of something that writes code faster than you.

What the format actually looks like

There were two kinds of rounds.

The coding round looked like a normal coding interview at first. A problem, a small codebase, and an interviewer watching. The difference is that Claude Code was open in my terminal, and the interviewer could see every prompt I typed, every change it made, and what I did with that change.

The system design round was a conversation, like usual. Design a system, talk through the tradeoffs, go deeper where the interviewer pushes. I could use the AI to brainstorm, sanity check numbers, or sketch out a schema, but I was still the one presenting the design and defending it.

In both cases, the thing they watched most closely wasn't the final answer. It was how I got there.

Your prompts are the new "thinking out loud"

In a traditional interview, you're told to think out loud so the interviewer can follow your reasoning. In an AI-assisted interview, your prompts do a lot of that job. They show how you broke the problem down, what context you thought mattered, which edge cases you were worried about, and whether you had a plan or were just hoping the model did.

A prompt like "solve this problem" says something about you. So does a prompt like "write a function that merges overlapping time slots, sorted by start time, where back-to-back slots stay separate, and add tests for empty input and fully nested slots first." The second one shows you understood the problem before you handed anything off. That's the whole game.

How I prepared

I used Hello Interview a lot for this. The part that helped most was their mock interviews for this format, where they evaluate your prompts and not just whether you got to a working solution. That was exactly the feedback I needed, because my bad habits were invisible to me.

My first few mocks went about how you'd expect. I'd read the problem, immediately ask the AI to solve it, get back a big chunk of code that looked right, and then spend the rest of the time trying to understand code I hadn't written. The feedback was blunt and fair. I was letting the model pick the approach, accepting large changes without reading them, and going quiet while I waited for it to finish. All three look bad when someone is watching.

After a handful of sessions, my approach flipped. Plan first, then prompt in small steps, then check everything. My solutions didn't get much faster. They got a lot more mine.

The moment it clicked

Here's the example that stuck with me. In one coding round, part of the task was merging overlapping booking slots for a scheduling feature. I described the function to Claude Code, it wrote a clean implementation, and the tests it wrote alongside it all passed. It looked done.

But before prompting, I'd written down a few edge cases of my own, and one of them was back-to-back bookings. If one meeting ends at 11:00 and the next starts at 11:00, the requirements said those should stay as two separate bookings. The AI's version merged them, because it compared times with "less than or equal" instead of "less than." Its own tests didn't catch it, because it wrote the tests based on its own assumption.

The tempting move was to type "that's wrong, fix it." Instead, I said out loud what the rule was and why, asked it to add a failing test for that exact case first, and only then asked for the fix. It took maybe two minutes. Afterwards, the interviewer mentioned that catching that, and the way I handled it, was the kind of thing they were looking for.

That's when it clicked for me. The AI didn't make a dumb mistake. It made a reasonable assumption about something the requirements were specific about. Catching that gap is the job, and it's exactly what you can't hand off.

The system design round had its own version. I asked the AI to suggest an architecture for a notification service, and it came back with a message queue, a fleet of workers, and a few microservices. For the scale we'd agreed on earlier, a few thousand users, that was way too much. Pushing back and explaining why a simpler setup fit better was a bigger part of the conversation than anything the AI suggested.

What steering actually looks like

Here's what I ended up doing every time, roughly in this order.

Understand the problem before opening the AI. Restate the requirements and ask the interviewer questions. The AI can't ask the interviewer anything, so whatever is unclear stays unclear unless you deal with it.

Write down your edge cases first. This is the single most useful habit I picked up. If you only test the cases the model thought of, you'll only catch the mistakes it already knows about.

Say your plan out loud, then give the AI small, specific tasks. Not "build the whole thing." One function, one piece, with the constraints spelled out.

Read everything it writes. If you can't explain a line, don't keep it. A good test is whether you could walk the interviewer through the change without looking at the AI's explanation.

Know when to stop prompting. A one-character fix is faster to type yourself, and doing it by hand shows you actually understand the code.

And keep talking. When you accept something, say why. When you reject something, say why. The silence while a model is thinking feels awkward on a call, and it's a good time to explain what you're expecting it to come back with.

Why I actually like this format

Funnily enough, I came out of these interviews liking them more than the traditional kind. At Bonsai Digital, I work with Claude Code every day, and this is a lot closer to what that looks like. Nobody at work asks me to reverse a linked list on a whiteboard. But I do constantly have to decide what to ask the AI for, check what it gives me, and catch the moment it confidently goes in the wrong direction.

These interviews test that judgment directly. Typing speed and memorized syntax barely matter anymore. Knowing what good looks like, and noticing when you're not getting it, matters a lot.

Wrapping up

The way I think about it now: the AI is an incredibly fast junior engineer who never asks clarifying questions. It'll happily build exactly what you asked for, even when what you asked for was slightly wrong. Your job in the interview is to be the senior engineer in the room. Set the direction, break down the work, check the output, and own the result.

If you have one of these interviews coming up, practice with the AI the same way you'll use it on the day, and get someone, or something, to look at your prompts. You steer. The AI drives. Don't let those switch.