AI-Assisted Coding Interviews: 6 Formats and How to Score Them

An AI assistant solves a classic coding interview question in seconds. When it does, the question stops telling the interviewer anything about the candidate. I wanted to show how companies check AI skills: how a candidate solves a problem with AI, implements a module, directs an agent, or picks the prompts. This article covers the six formats they use, how to score them, a 60-minute template, and what the first pilots learned.

Why the classic coding interview stopped working

Per Coinbase It gave candidates full AI access on its standard frontend questions, and the AI solved most of them. With the AI switched on, the round tested the model, not the engineer, so Coinbase rebuilt the questions instead of keeping them.

A round that replaces the classic one has to meet three requirements:

• Show the engineer's judgment, not the model's output. The AI writes most of the code, so the score has to come from what you decide, check, and reject.
• Keep candidates comparable. Candidates arrive with different tools, models, and setups. Nobody should pass because they pay for a better model.
• Survive the next model. A task the AI can't solve today can be easy after the next release, so every question needs regular re-testing.

What is an AI-assisted technical interview?

In an AI-assisted interview, the AI sits on the candidate's side. You get an assistant or a coding agent, a realistic task, and usually an existing codebase. A human interviewer watches your work and scores it with a rubric. This isn't an "AI interviewer": no model decides whether you pass.

I covered the questions about AI tools (RAG, agents, MCP) in AI-Related .NET Interview Questions. This article is about the round where you use them.

Companies run this round in one of three ways:

• A standard environment. Every candidate gets the same codebase and the same built-in assistant. Karat's NextGen uses a VS Code-based IDE with an integrated assistant and forbids outside AI tools. Meta's round runs in CoderPad with a built-in chat, according to candidate reports.
• Your own machine. You work in your own IDE with your own tools. DoorDash asks for this, and Canva lets you bring Copilot, Cursor, or Claude.
• A designated round in a mixed loop. One round requires AI, and the others forbid it. Datadog tells candidates in advance: "You will be explicitly told in advance if you will be in an AI coding interview."

Note: The first two requirements pull in opposite directions. A standard environment keeps candidates comparable. Your own machine is closer to real work, but every candidate brings a different setup.

Which companies run AI-assisted coding interviews in 2026?

Most of these rounds are still pilots. The Source column shows where each detail comes from: a company's own blog, a vendor's docs, or press and candidate reports.

Six AI interview formats

I left out prompt-only contests. They measure how well you know one tool, not how you engineer with it.

1. Brownfield repair and extension

You get an existing service of 10 to 30 files that you didn't write. You find a defect, add a feature, then improve a quality, such as performance or error handling. It's hard to pass by pasting generated code, because the AI needs your context to change the right thing.

For example: POST /orders creates duplicate orders when a client retries. You read the service, find the half-finished idempotency code, fix it, and add the test that proves it.

Coinbase's repo-based debugging round, Meta's round, and Karat's NextGen all follow this shape. If you run only one AI round, I'd start with this format: it gives the most signal per minute, and the template below uses it.

2. AI pair-programming on a product task

You build a feature from a vague product request, with the assistant as your pair. Canva's example: "Build a control system for managing aircraft takeoffs and landings at a busy airport." Nobody can solve that with one prompt, so you ask questions, break the system down, and give the AI well-defined parts.

Canva's interviewers describe three ways candidates fail here: the "AI Showcase" (showing off the tool instead of solving the task), the "Feature Marathon" (rushing through many features), and "Hands-Off" (delegating everything to the AI). Their summary: "We're assessing your engineering capabilities enhanced by AI collaboration, not your AI skills in isolation."

Limit. If the feature is small or fully specified, the AI finishes it alone, and the round shows nothing. Keep the request ambiguous enough that it needs decisions.

3. Agent delegation

You get a coding agent, such as Claude Code, Codex, or Cursor in agent mode, and you direct it instead of typing. CodeSignal's Agentic Interviewing supports these agents in live interviews. Most of the skill is in the task spec:

Goal: make POST /orders idempotent for retried requests.
In scope: OrdersService.cs, IdempotencyStore.cs.
Don't touch: the public API contract, existing tests.
Done when: dotnet test passes, plus a new test for a duplicate request.
Stop and ask before adding a package.

Then you review the agent's diff, run the tests, reject what's wrong, and delegate a second, smaller change.

Limit. Agents are less predictable than a chat. Two candidates with the same spec can get different diffs, so score the review and the re-prompt, not the first diff.

4. Reviewing AI-generated code

You review a large AI-generated pull request with planted defects: a missing authorization check, an N+1 query, a new dependency nobody needs, or a test that checks only the happy path. The format tests skepticism and code reading, and one-shot generation can't pass it.

The planted defects are the same ones AI produces in real pipelines. As explained in AI Across the SDLC, Part 1, generated code passes review because it looks plausible.

Cost. Someone has to build and maintain the seeded pull request. When a new model stops making a planted mistake, the defect starts to look artificial.

5. Compressed delivery sprint

You get a backlog that would take several days: request classification, retry handling, an audit trail, API tests, and an operations note for a support service. You have 30 minutes, and nobody expects you to finish. The round checks which slice you pick, how you split and delegate the work, what you verify, and how you hand over the rest. It suits senior and staff roles, where prioritization matters more than typing.

Limit. Don't call it "a week of work in 30 minutes". It compresses the planning and the orchestration, not a week of validated production work.

6. Agent toolchain setup

You configure the AI environment before you solve a small task: the model, the agent's permissions, the network scope, and the tools it may call. One available tool has too many permissions, and another sends repository code to an unapproved external service. The round checks whether your setup is safe and still productive.

Agent tools now expose these controls directly: allowed and denied tools, approval modes, sandboxes, and MCP server lists. Read more about MCP in the article: What is the Model Context Protocol (MCP).

Limit. For a general software engineering role, setup friction is noise. Use this format for platform, developer productivity, and staff roles, where engineers own the agent setup.

How to score an AI-assisted interview

Don't score the AI's output, the number of prompts, or raw speed. Karat's rubric says candidates should be neither "penalized nor implicitly rewarded for AI-outputs". Speed is a weak signal too: in METR's 2025 study, experienced developers in mature repositories took 19% longer with AI, while they believed they were faster.

Score the shape of the loop instead:

Weak loop
prompt -> output -> accept -> continue

Strong loop
inspect -> hypothesis -> scoped prompt -> inspect diff
        -> run a targeted test -> see the failure
        -> new hypothesis -> narrower prompt or manual fix
        -> verify -> integrate

Six prompts that converge on a fix after failing tests show more engineering than one broad prompt that happened to work.

Use a 100-point rubric. Rate each dimension from 0 to 4, then multiply by its weight divided by 4:

Set the pass mark at 70 out of 100 for a pilot, with three gates: verification, implementation, and security; each needs at least 2 out of 4. I'd put gates into any rubric for this round. An average hides the one mistake that should fail a candidate on its own: a candidate with 82 points who pasted a credential into an external service would still pass.

Note: These weights and thresholds are starting points, not validated cutoffs. Adjust them after your first pilot rounds.

A 60-minute AI interview template you can reuse

The template uses the brownfield format from above.

The task. A small HTTP service with a persistence layer and tests. POST /orders creates a duplicate order when a client retries. An unfinished idempotency abstraction already exists, one test covers the normal path, and the logs include too much request data. The goal: make order creation idempotent without breaking current behavior.

Constraints, shared only when the candidate asks. Requests carry an idempotency key, keys stay valid for 24 hours, several instances run at once, and payment details must never reach the logs.

The trap. The assistant will likely suggest an in-memory dictionary first. At minute 42, the interviewer says: "Production traffic is distributed across four instances. The in-memory approach no longer satisfies the requirement." A strong candidate moves the idempotency state into the shared store, updates the tests, and fixes the logging along the way.

Probes for the interviewer. Ask these during the session, without coaching:

• "Why did you delegate this step?"
• "What makes this response trustworthy?"
• "Which part of this diff worries you?"
• "How would you verify this without asking the model again?"

What to write down. Not "Candidate seemed good with AI." Record what you saw: "Candidate searched the repository for the persistence interface, asked the assistant to compare two implementations without editing files, and limited the change to two files. The generated change missed concurrent duplicates. Candidate saw it in the failing test, rejected the process-local cache, and moved the state into the shared store."

Run it fairly. Three controls keep the round comparable:

• Give everyone the same AI. Provide the model, unless choosing it is part of the job.
• Record the model and its version. A model update can make a task easier from one month to the next.
• Re-test the questions every quarter. Coinbase reviews its questions quarterly because new models keep solving old ones.

What's next for AI interviews

Coinbase is testing system design rounds with AI, and Google's code comprehension round has expanded to more formats but remains a pilot, according to Business Insider (October 2026). The other change is legal. Once a model watches the session and produces a score or a ranking, it evaluates candidates, and the EU AI Act lists AI that evaluates job candidates as high-risk, with obligations from December 2, 2027.

Conclusion

Rebuild the question; don't switch the AI on. Use an old question with AI-enabled tests to test the model. Build the task around decisions the model doesn't own: an unfamiliar repository, an ambiguous request, a requirement that changes in the middle of the session.

Score the loop, not the output. Weight verification highest and gate on it. For candidates, the rubric is the preparation guide: practice on a repository you don't know, run the tests after every AI change, say why you accept or reject a suggestion, and keep your fundamentals. You can't steer an AI through a problem you couldn't solve yourself.

Keep a human on the score. Let the model help the candidate, and let the interviewer decide and write down the evidence. A model that scores candidates turns the round into a high-risk system.

Future reading

• AI-Related .NET Interview Questions and Answers (2026): LLMs, RAG, Agents, Claude Code, Cursor, Copilot and MCP
• AI Across the SDLC, Part 1: Seven Ways AI Breaks Your Delivery Pipeline
• AI Across the SDLC, Part 2: Where AI Fits and What Controls It
• What is the Model Context Protocol (MCP)
• .NET Interview Questions and Answers: 800+ Questions for Beginners, Seniors & Architects