What is an AI-assisted coding interview?
An AI-assisted coding interview is a coding interview in which the candidate may use an AI coding assistant, and is judged on how they use it. Canva's engineering blog said in June 2025 that it now expects backend, machine-learning and frontend candidates to use tools like Copilot, Cursor and Claude in its technical interviews.
In Canva's post (11 Jun 2025), the AI-assisted round replaces its Computer Science Fundamentals screening for backend and frontend roles. Canva's interviewers look for five things: whether the candidate knows when to use AI and how, how they break a vague requirement into parts, whether their technical decisions hold up while AI speeds up the work, whether they find and fix mistakes in the code AI wrote, and whether the result meets production standards.
The coding-test vendors have built the same idea into their editors. Each puts an assistant beside the candidate's code and gives the reviewer a record of how it was used.
| Tool | What the candidate gets | Who switches it on | What the reviewer sees afterwards |
|---|---|---|---|
| CodeSignal | Cosmo, an AI assistant inside the coding environment | The employer, choosing Full AI Co-Pilot or Guided Support mode | A full transcript of the candidate's chats with the AI, and a session replay |
| Codility | AI Copilot, with chat, agent and autocomplete modes | The interviewer, who can turn it on or off at any point in the session | The candidate's prompts and the transcripts, in the post-interview report |
| HackerRank | An AI Assistant in the interview's code editor, in Guarded or Unguarded mode | An admin, set to always on or chosen per interview | A Chat Transcript of the candidate's conversation with the assistant, in the report |
Source: CodeSignal's announcement, Codility's AI Copilot post and HackerRank's help centre, each undated, read 17 Nov 2026 · listed alphabetically
In all three, the assistant runs inside the vendor's own editor, so the reviewer can read what the candidate asked it.
Should you allow AI in a coding interview?
Allow AI when the client's engineers code with it every day and you can judge how the candidate uses it. Bar it when the round has to show what the candidate can write alone. Either way, say which in the question itself, before the candidate starts. The call is yours and the client's.
Allow AI when:
- the client's team uses AI assistants in its daily work;
- the question asks for decisions, trade-offs and tests, not a textbook routine;
- a live round follows, where an engineer can ask about the code.
Bar AI when:
- the role needs the basics checked on their own, as with a batch of freshers or an algorithms-heavy role;
- the client has said no;
- your tool gives you no record of what was pasted.
Hiring advice from coding-interview platform CoderPad points the same way. In a Dec 2023 post on bringing ChatGPT into technical interviews, it says a candidate who uses ChatGPT should be open about it and ready to explain the reasoning behind the code.
If you said nothing and a candidate used AI anyway, the guide to interview cheating covers whether AI use counts as cheating and what to do next.
How do you write a coding question when AI is allowed?
Ask for what an assistant doesn't hand over on its own: the candidate's reasons, the trade-offs they chose and a test that proves the code works. Put the AI rule in the first line of the question, so every candidate answers under the same rule.
- State the rule in the first line: AI allowed, allowed if disclosed, or not allowed.
- If AI is allowed, ask where they used it and what they changed.
- Ask for a comment on one design choice, such as an index or an error case.
- Ask for a test that checks what the code does.
- Tie the task to the client's stack and a real constraint.
- Plan one follow-up question on the code for the client's live round.
A question written this way works in any tool. The reasons and the test are what tell two candidates apart when both had the same assistant.
How Recagn does this
Recagn is our product. Recagn reads code answers (not run) against the role's rubric and records every paste into the code editor, with the file it went into. You see the code, the pastes and the reasons behind each score, and you judge whether AI wrote the code against the rule you set.
What the candidate gets. A code editor in the browser, with up to 10 files per answer, highlighting for 20 languages and search. It has no autocomplete. Under the editor, Recagn tells candidates "Code isn't run in this Interview." Pastes into the editor are allowed.
What you see. Each paste into an answer, with the pasted text and the file it went into. Longer pastes from outside the page are marked as coming from outside. A paste outside the answer is blocked. Candidates are told before they start that Recagn keeps anything they copy from or paste into the interview.
When pastes become a flag. Repeated pastes from outside the page are one of the signals behind Integrity, which reads No, Some or Strong concerns and is flagged for you to judge. When a paste counts is set out in the Integrity rules. Integrity stays out of the score, the ranking and the client's Company Report.
How the code is judged. Recagn's scorer is told the code was not run and to judge it by reading it, and it scores the rubric criteria the question is linked to.
Where your AI rule lives. In the question text you write. Recagn shows every candidate the same question, so every candidate answers under the same rule.
Open a file to read the code. Recagn reads it without running it and scores the criteria the question is linked to; each reason also draws on his other answers.
Rohan D. Recommendation: Qualified
Code answer (not run)
Write the Java code for GET /customers/{id}/orders: it returns the customer's 20 most recent orders with their line items, in as few database queries as you can. Use Spring Boot with JDBC or JPA, as you prefer. Include a unit test, and say in a comment how you would index the tables.
4 of 10 files · Java
OrderController.java Java
package com.example.orders;
import java.util.List;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class OrderController {
private final OrderQueries queries;
public OrderController(OrderQueries queries) {
this.queries = queries;
}
@GetMapping("/customers/{id}/orders")
public ResponseEntity<List<OrderView>> recentOrders(@PathVariable long id) {
if (!queries.customerExists(id)) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(queries.recentOrders(id, 20));
}
}
OrderQueries.java Java
package com.example.orders;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;
/**
* Two queries, whatever the order count: the 20 orders, then all their line items in one IN.
* A single JOIN with LIMIT would cut items, not orders, so the limit runs on orders alone.
*
* Indexes:
* CREATE INDEX orders_customer_recent ON orders (customer_id, created_at DESC, id DESC);
* -- the WHERE and ORDER BY walk this index; no sort, stops after 20 rows
* CREATE INDEX order_items_order ON order_items (order_id);
* -- the IN lookup; add (order_id, id) if item order matters on large orders
*/
@Repository
public class OrderQueries {
private final NamedParameterJdbcTemplate jdbc;
public OrderQueries(NamedParameterJdbcTemplate jdbc) {
this.jdbc = jdbc;
}
public boolean customerExists(long customerId) {
Boolean exists = jdbc.queryForObject(
"SELECT EXISTS (SELECT 1 FROM customers WHERE id = :id)",
Map.of("id", customerId), Boolean.class);
return Boolean.TRUE.equals(exists);
}
public List<OrderView> recentOrders(long customerId, int limit) {
Map<Long, OrderView> orders = new LinkedHashMap<>();
jdbc.query("""
SELECT id, status, total_paise, created_at
FROM orders
WHERE customer_id = :customerId
ORDER BY created_at DESC, id DESC
LIMIT :limit
""",
new MapSqlParameterSource("customerId", customerId).addValue("limit", limit),
rs -> {
long id = rs.getLong("id");
orders.put(id, new OrderView(id, rs.getString("status"), rs.getLong("total_paise"),
rs.getTimestamp("created_at").toInstant(), new ArrayList<>()));
});
if (orders.isEmpty()) {
return List.of();
}
jdbc.query("""
SELECT order_id, sku, quantity, price_paise
FROM order_items
WHERE order_id IN (:ids)
ORDER BY order_id, id
""",
Map.of("ids", orders.keySet()),
rs -> {
orders.get(rs.getLong("order_id")).items().add(new OrderView.Item(
rs.getString("sku"), rs.getInt("quantity"), rs.getLong("price_paise")));
});
return List.copyOf(orders.values());
}
}
OrderView.java Java
package com.example.orders;
import java.time.Instant;
import java.util.List;
public record OrderView(long id, String status, long totalPaise, Instant createdAt, List<Item> items) {
public record Item(String sku, int quantity, long pricePaise) {}
}
OrderQueriesTest.java Java
package com.example.orders;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
/** Runs against a real PostgreSQL (Testcontainers, via the test profile), not mocks. */
@JdbcTest
@Import(OrderQueries.class)
@Sql("/orders-fixture.sql") // customer 1 with 25 orders of 2 items each; customer 2 with none
class OrderQueriesTest {
@Autowired OrderQueries queries;
@Test
void returnsTheTwentyMostRecentOrdersWithAllTheirItems() {
var orders = queries.recentOrders(1, 20);
assertThat(orders).hasSize(20);
assertThat(orders).isSortedAccordingTo((a, b) -> b.createdAt().compareTo(a.createdAt()));
assertThat(orders).allSatisfy(o -> assertThat(o.items()).hasSize(2));
}
@Test
void aCustomerWithNoOrdersGetsAnEmptyList() {
assertThat(queries.customerExists(2)).isTrue();
assertThat(queries.recentOrders(2, 20)).isEmpty();
}
@Test
void anUnknownCustomerDoesNotExist() {
assertThat(queries.customerExists(999)).isFalse();
}
}
- Java full-stack developmentweight 25%
Criterion score, from all his answers linked to it
Recagn's reason: Strong across Java (Spring Boot enterprise APIs with idempotency, versioning) and React (react-query, optimistic updates), with full-life-cycle ownership and measurable performance outcomes (14 min to <3 min). The code answer is clean, avoids N+1 with two batched queries, limits/orders in SQL, 404 for unknown customer, and a behaviour-focused Testcontainers test. Node.js experience is not explicitly shown, which is the main gap preventing a 5; otherwise this is near-expert depth.
- Databases & SQLweight 10%
Criterion score, from all his answers linked to it
Recagn's reason: Deep data expertise on a 40M-row table: diagnosis via EXPLAIN ANALYZE, functional and partial indexing, subquery-to-join rewrite with a dramatic measurable improvement (6s to 90ms), plus connection-pool tuning. Schema design (immutable versioned tables) and thoughtful composite-index reasoning in the code answer reinforce this. Matches level 5 for optimising enterprise databases for performance and scale. NoSQL is not demonstrated, but relational depth and the overall strength justify 5.
The question in this worked example ends with "say in a comment how you would index the tables". Rohan D. did, and Recagn's reasoning for Databases & SQL credits his "thoughtful composite-index reasoning in the code answer". That is the third item on the checklist at work: a written reason is evidence the scorer reads, whoever typed the code. The full walkthrough of how the files are scored is on how Recagn screens developers with a code question.
Recagn recommends. Only you can reject a candidate. Recagn does the screening. You make the calls.
Recagn's Skills Assessments and IDE with AI phase will run a candidate's code against tests and play back how the code was written. It is on the roadmap, where you can ask for early access.
Questions people ask
Can Recagn tell whether a candidate used ChatGPT to write their code?
Recagn shows you every paste into the code editor, with the file it went into and the pasted text, and marks the longer pastes that came from outside the page. Repeated ones are flagged for you to look at. You decide whether AI wrote the code, against the rule you set in the question. Asking for the candidate's reasons and a test shows you more.
Does HackerRank let candidates use AI in coding interviews?
Yes. HackerRank's AI-Assisted Interviews put an AI Assistant in the interview's code editor, switched on for every interview or chosen per interview, and the report carries a Chat Transcript of the candidate's conversation with it, going by HackerRank's help centre, read 17 Nov 2026.
Does allowing AI in a code question change what a Recagn interview costs?
No. Your AI rule is a line in the question text, and a code question adds no credits either way. An interview with a code question, no video answer and no webcam proctoring uses one credit: at most ₹50 on Starter before GST (₹49.98; ₹58.98 with 18% GST). How that sits beside coding-test prices is on Recagn's coding screening page.
Will Recagn run the code or show how it was written?
Not yet. Running a candidate's code against tests and playing back how it was written are planned in the Skills Assessments and IDE with AI phase of Recagn's roadmap, where you can ask for early access.