Here is an example of what a technical interview should look like in 2026…

A candidate opens a repository for Shipway, a software deployment platform. They receive a ticket the same way they would on day one of the job: pulled from a project management tool, assigned to them, with full context. The ticket: customers are reporting issues with deployment creation.

The agent is available immediately. The interviewer watches everything live. What happens next is three phases, Plan, Build, and Review, each designed to surface a different dimension of how the candidate works.

Phase 1: Plan

The candidate’s first move isn’t to start coding. It’s to prompt the agent to build a plan for the ticket.

The agent responds with an approach and asks clarifying questions. The candidate responds, refines, and pressure-tests. This exchange is the core of the interview; by design, the planning phase takes up more than half the total time.

While this is happening, the interviewer is asking questions.

• What’s the approach?
• What are the tradeoffs?
• What could go wrong?
• What would you do differently?

This is where you learn how a candidate thinks about a problem, before a single line of code is written. You’re watching whether they can hold a plan in their head, interrogate its assumptions, and make deliberate decisions about what to change and what to protect.

When the plan is complete, the candidate moves on. But the plan itself is already a signal.

Phase 2: Build

Once the plan is set, the candidate doesn’t write a single line of code.

They prompt the agent to build according to the plan. The agent gets to work: lines rewrite, files update, the diff grows. For a single ticket like this one, the candidate is reviewing one agent in real time. In a real job, they might be managing three agents working in parallel across different parts of the codebase.

The interview tests the underlying skill: can they keep an agent honest to a plan?

The interviewer is watching two things.

• Can the candidate spot when the agent drifts from what was agreed?
• And when it does, because it will, can they pull it back?

This phase rewards candidates who stay engaged throughout. The ones who let the agent run and wait for it to finish are a different class from the ones who are actively supervising, redirecting, and shaping the output as it’s being produced.

Phase 3: Review

When the agent finishes, the candidate runs the existing test suite to see what’s passing and what’s breaking. They can also write their own tests to catch edge cases the agent might have missed.

Then the review begins in earnest.

The platform automatically generates interview questions based on the specific lines of code added, the prompts the candidate sent to the agent, and the actions the agent took during the session. These aren’t templated questions. They’re pointed and specific to what was just built: why was this file changed? What does this function do? What happens if this edge case isn’t handled?

The interviewer also probes directly:

• walk me through the diff.
• What did the agent modify, and why?
• Is this safe to ship?

This phase matters more than it used to. Most of the code being shipped today is AI-generated. Review has gone from a routine quality check to the last line of defense: the moment when a human decides whether the output is correct, complete, and safe to deploy. Get it wrong and you ship an outage or a security breach.

The review phase is where that judgment becomes visible.

What the Interview Measures

Across all three phases, the interview generates an AI fluency score, automatically derived from the transcript of how the candidate worked with the agent from start to finish. It captures:

• How they structured the plan and whether they owned the direction
• How they supervised the build and whether they caught drift
• How they reviewed the output and whether they knew what was safe to ship

Correctness is still part of the score. But it’s table stakes. The headline signal is judgment: the ability to direct, supervise, and verify an AI agent toward output that’s actually ready to go to production.

That’s what developers do now. The interview should test it.

Watch the agentic interview in action. Book a demo