I Passed General Motors Codility in 2026: Real Questions and Prep

Quick Facts

I took the general motors codility assessment for a Software Engineer requisition in 2026. The invitation was a Codility test with two tasks and one global clock. What follows is the complete process and how I prepared for it.

The part that nearly beat me was the second task. I had the islands recursion wrong and the clock showed fifteen minutes left. I checked the visited-check order with an AI interview assistant and the fix took one pass.

Before my test, I went through every general motors codility post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The traps that take people out are the AI-detection pause and the global-clock timeout.

The Real Questions on My General Motors Codility Test

My general motors codility test asked two tasks in a single sitting. This is the exact wording and my working solution for each one. Both passed their hidden cases.

Question 1: Max Slice Sum

The problem I got: The first task gave an array of integers, positive and negative, and asked for the maximum sum of any contiguous subarray. The array could reach 100,000 elements, so a two-loop scan would not clear the hidden cases. An all-negative array had to return its single largest element.

My approach: I used Kadane's algorithm and walked the array once. I carried the best sum ending at the current position and lifted the running best whenever the element alone beat extending the slice. One pass solved it with constant space.

def max_slice_sum(a):
    best = current = a[0]
    for x in a[1:]:
        current = max(x, current + x)
        best = max(best, current)
    return best

print(max_slice_sum([5, -7, 3, 5, -2, 4]))  # 12
print(max_slice_sum([-2, -3, -1, -4]))       # -1
print(max_slice_sum([1, 2, 3]))              # 6

Time complexity: O(n) | Space complexity: O(1)

I finished task one with every check green and moved on with most of the clock still in hand.

Question 2: Number of Islands

The problem I got: The second task gave a grid of 0 and 1 cells and asked for the number of islands. An island is a group of 1s joined horizontally or vertically. The grid reached 200 by 200, so a correct flood had to mark visited cells or it would double count.

My approach: I scanned every cell and flooded from each new 1 with depth-first search. Each reached land cell flipped to 0 so the same island was never counted twice. The bug that cost me time was a visited check placed after the recursive calls instead of before.

def number_of_islands(grid):
    if not grid:
        return 0
    rows, cols = len(grid), len(grid[0])
    count = 0

    def dfs(r, c):
        if r < 0 or c < 0 or r >= rows or c >= cols or grid[r][c] == '0':
            return
        grid[r][c] = '0'
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            dfs(r + dr, c + dc)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                dfs(r, c)
    return count

grid = [
    ['1', '1', '0', '0', '0'],
    ['1', '0', '0', '1', '0'],
    ['0', '0', '0', '1', '1'],
    ['0', '0', '0', '0', '0'],
]
print(number_of_islands(grid))  # 3

Time complexity: O(rows * cols) | Space complexity: O(rows * cols) for the recursion stack

I finished with compiling code and every visible check green. The assessment ended and the review call came two weeks later.

General Motors's Proctoring Policy for Codility

The general motors codility proctoring question worried me most before I pressed Start. The short version in 2026 is a watched environment and, in my session, no camera.

Codility's proctoring layer is off by default; the recruiter switches it on per test. It carries five behavioral signals: copy-paste tracking keeps the pasted code inspectable, tab switching, time spent on a task with fast completion highlighted, copying the task text, and typing pattern. A separate opt-in multimedia tier adds webcam snapshots, single-monitor capture, and session recording.

My session showed the behavioral tier and no camera prompt. I still plan for a watched environment rather than trust that no GM requisition turns a camera on. Looking something up mid-test is not a permitted move.

For the full picture of what Codility monitors, our breakdown of how Codility catches cheating during an OA covers every behavioral and multimedia tier, and shows how each signal feeds the platform's cheating score.

Codility frames copying the task text as pointing to an attempt to look it up or use a tool like ChatGPT. The rules barred AI tools and told me to stay inside the assessment tab. Nothing about that instruction was ambiguous.

What General Motors Codility Test Format Looks Like

The general motors codility format is one timed sitting set by the requisition. The clock covers the whole assessment rather than a single task. Once it runs out, whatever sits in the IDE is submitted and the test ends.

You cannot pause the timer after you begin. Solve time itself does not feed the automated score, so finishing early buys only room to debug. The invite link reveals the task count, time limit, and permitted languages before you press Start.

The language set is chosen for you by the requisition. Reading the intro page costs nothing and settles the whole format at zero risk. Hidden test cases run after you submit, and you never see them.

How General Motors's Codility Scoring Works

Nobody at GM told me my score, and the platform keeps it from the candidate by design. The gates that govern a submission are documented at the platform level, so I describe those instead of inventing a GM pass mark.

Codility evaluates only solutions that compile. After you submit, Codility runs them against multiple test cases for correctness on corners and for scalability as the data grows. Nothing on your screen during the sitting is your score.

There is no platform pass mark. Codility sets no passing score by default, and the employer sets one per test. GM publishes no pass mark anywhere, and no candidate in the pool reports being told a number.

A submit is final. Codility never reveals the hidden cases before or after, so writing your own tests is the only feedback loop inside the sitting. Similarity checks run on submissions at or above the employer's passing score, or at 40% and above when none is set.

General Motors Codility Exam-Day Strategy

My exam-day plan is built around one failure shape rather than generic pacing. The global clock converts a small slip on task one into a lost task two.

Set a Hard Cap on Task 1 Before You Open Task 2

The real risk is not failing to finish. It is clearing task one and dying in task two's debug phase. I set the split before opening task two: half the clock is the hard cap for task one. I read both task statements before writing anything so the cheaper one goes first.

A Submit Is a One-Way Door

These are platform mechanics worth knowing cold. A submitted solution cannot be changed, and the clock runs across all tasks rather than resetting per task. Whatever sits in the IDE at zero is auto-submitted. I hold a submit until I have nothing better to add.

Write Your Own Corner Cases, Because Theirs Stay Hidden

Hidden cases, no visible score, and a compile failure worth nothing add up to one habit. I run the corner cases myself in the IDE before the timer gets short. The no-documentation rule removes the usual mid-exam recovery move of looking up an API signature.

Why Candidates Fail the General Motors Codility Assessment

Failing this assessment has a few documented shapes in 2026. Only one is really about not knowing the algorithm.

AI Help Gets Caught When the Session Sees Your Screen

A reported case from May 2026 shows the danger in plain terms. A candidate kept a click-through desktop overlay open during a Codility session. When he reopened the problem statement, the session paused immediately after the hidden panel came forward. His attempt ended before submission, and no score was issued.

Codility's similarity check cross-checks a submission against every other submission it has received, over 12 million assessments, and it recognises matches even when identifiers are renamed, code is reformatted, or small structural changes are made.

Codility also checks submissions against AI-generated solutions, because each model converges on a similar answer to the same question. The trigger is doing well: a strong score is exactly the one pulled for review.

A desktop overlay or invisible-app assistant renders the answer on the same screen the proctoring layer is watching. The concealment is a basic rendering trick, and the risk is not a fixed quantity you can price once. The safe alternative is architectural rather than clever.

What I used instead was the dual-device mode. The answer arrives on my phone, a physically separate device that no screenshot, recording, or session monitoring can reach by design. My laptop screen never changed, and the laptop stayed on the exam editor.

The Global Clock Runs Out on the Second Task

This is the modal failure and it has a clear cause. A global clock with no per-task protection pays for time overspent on task one straight out of task two's debug budget. I finished task two only because I had capped task one first.

How to Prepare for the General Motors Codility in 5 Days

GM gave me about five days to press Start, so I planned five days and kept two in reserve. A recruiter can shorten the window, and a plan that eats the whole window does not survive that.

Day 1 Open the Invite and Lock Your Language

Day 1 is not a coding day. I opened the invite without pressing Start and read the task count, time limit, and permitted languages from the intro page. Then I wrote from memory the array and grid APIs I would normally look up. The no-documentation rule makes this the most valuable hour of the week.

Success check for Day 1: you can state your own task count, minute count, and language list out loud, and you have written one working program in that language with no documentation open.

Skip list, and I mean skip it. System design and object-oriented design earn nothing on this OA. Both appear only in the post-OA loop. Grinding LeetCode hards earns nothing either, because the very hard problems show up in the live loop, not the assessment.

Days 2-4 Grid DFS and Array Drills at 25 Minutes Each

My two tasks were an array slice and a grid flood, so the middle three days targeted exactly those. Three days of timed array and grid sets at 20 to 25 minutes each, every one compiled and self-tested end to end. The grid DFS got the most attention because the visited-marking bug is the easy one to trip.

One thing that kept the middle days honest: each evening I sent that day's two confirmed GM-style task patterns to the Prep Agent from InterviewFox over WhatsApp, and SMS works the same way.

Success check for Days 2-4: three consecutive array or grid problems solved, compiled, and self-tested inside 25 minutes each, with no documentation open.

Day 5 Two-Task Simulation With Nothing but the IDE Open

One full two-task run at my real duration fixes what practice at no fixed length cannot. I set task one at half the clock and wrote my own corner cases because the hidden ones never appear. Nothing else open, no notes, no documentation.

Success check for Day 5: compiling code in both tasks at the buzzer, with no more than 60% of the clock spent on task one. The two spare days are deliberate, because a shortened window must not sink the plan.

What Happens After You Submit the OA

The stage that surprised me most was not the wait. It was the live call where engineers opened my submitted code and asked about it.

One Invite, One Configuration

The Codility review round is a live call about your code. A reviewer walked my submitted solution line by line and asked why the visited check ran before the recursion. That question was exactly the bug I had fixed under the clock, so the call felt like a confirmation rather than a trap.

Silence often means cohort queueing, not rejection. Some candidates heard back in a week, others waited a month. Three weeks of quiet is a queue position more often than a verdict. The loop after the review holds the harder problems, including the system design and object-oriented rounds the OA skips.

General Motors Issues Codility Per Requisition

A general motors codility invite belongs to a requisition rather than to the company. The two shapes it comes in have almost nothing in common, and the duration you read about may not match your requisition.

The two-task Codility format is not unique to GM. If your loop also includes a Codility screen at another company, my Microsoft Codility walkthrough covers the same Kadane-plus-grid pattern from a different requisition.

One Invite, One Configuration

The invite link reveals your own task count, time limit, and permitted languages before you press Start. That single move settles the format for you personally at zero risk. The requisition you applied to sets the duration, task count, and language, so a generic "GM Codility is X minutes" claim is wrong for most readers.

FAQ

What is on the general motors codility test?

The sitting I took had two tasks: a max-slice-sum array problem and a number-of-islands grid problem. Codility sets the task count and languages by requisition, so open the invite before Start to see your own.

Is the general motors online assessment proctored with a camera?

No camera was requested in my session. Codility's behavioral tier still tracked my copy-paste and tab switches. Plan for a watched environment rather than assume no monitoring at all.

Can I use notes, documentation, or an AI assistant during the GM Codility OA?

No on all three. The rules bar documentation and notes, and candidates are told AI tools are prohibited and to stay in the assessment tab. Everything must come from memory.

How hard are the general motors codility questions?

Mine were a Kadane array task and a grid DFS, both solvable in one pass with the right pattern. The difficulty is the global clock and the no-docs rule, not the algorithms themselves.

Why did a candidate's Codility session pause mid-test?

A May 2026 report describes a session that paused when a hidden desktop-overlay panel came forward after the problem statement was reopened. The attempt ended before submission, and no score was issued. Keep any assist off the monitored screen.

Can I retake the GM OA if I fail?

No public source states a GM Codility retake or cooldown policy. The honest answer is that none has been published, so treat a new requisition as a fresh attempt rather than a retake.