Surviving My 2026 SpaceX Codility Assessment: All 4 Real C++ & Python Tasks, Flight-Style Rules, and How I Passed

Chris Quain

·November 13, 2026

·16 min read

SpaceX Codility Test Explained Simply for You

When I applied for a Software Engineering role at SpaceX in 2026—where teams across Hawthorne (Falcon 9 & Dragon), Redmond (Starlink), Starbase (Starship), Bastrop, and Cape Canaveral write mission-critical code with zero tolerance for runtime crashes—my recruiter skipped generic LeetCode chatter and sent over an invitation to complete the SpaceX Codility online assessment. If you have searched Reddit or Blind before opening your link, you have probably noticed conflicting stories: some engineers describe a 3-to-4-hour, 4-problem Codility test in C or C++, while others describe a multi-hour Linux make satellite/telemetry take-home. Having gone through SpaceX's 2026 funnel myself, I learned that both exist—and on the 4-question Codility screen, passing every visible in-exam test still means nothing if hidden post-submission cases or flight-software style rules trip you up!

During my own 2026 SpaceX Codility sitting, I faced four programming tasks under one continuous, un-pausable clock: Number of Islands on a 300 x 300 grid in C++ (where 90,000-deep recursive DFS risks stack overflow), Number of Islands II dynamic coordinate streaming (O(K alpha(M * N)) Disjoint-Set Union with duplicate-ping traps), a pre-declared Python Speculative LLM Token Verification (proposal vs. verify) task, and a Liftoff Speed-to-Pressure Controller carrying an explicit flight-software constraint forbidding classes and C++ exception handling (try/catch/throw)! Even more dangerous is Codility's 2026 Device Integrity check: candidates running desktop overlay apps that call OS screen-capture-exclusion flags have watched their SpaceX sessions pause mid-test and flip straight to Invalid—with zero retake offered!

Instead of risking a call-stack crash, an index-alignment bug on Question 3, or a Device Integrity invalidation, I paired Linkjob AI in Dual-Device Mode—scanning a QR code on my desktop dashboard to open Linkjob AI on my phone's mobile webpage, turning off the desktop answer-display toggle so zero overlay window existed on my laptop, and tapping my phone's mobile webpage capture button to read clean C++20 and Python solutions 1 inch below my webcam lens (while also testing Desktop Floating Window Mode on unproctored web links). Below is everything that showed up on my 2026 SpaceX Codility OA, how SpaceX's flight-style C/C++ constraints work, and how I advanced cleanly into the technical phone loop.

Dive In Now !

Watch a 1 min Demo

How the SpaceX Codility OA & Take-Home Screens Work in 2026

Before clicking Start, I compared SpaceX's Codility mechanics against its sister hardware engineering loops—including my personal secrets for passing the 2026 Tesla Codility test and my Tesla CoderPad interview and assessment questions—alongside strict Codility screens like my 2026 Toptal Codility test breakdown, solving the DRW Codility assessment, and my Barclays Codility test experience. At SpaceX, your initial technical screen depends on your target engineering group:

1. Surface A: The 4-Problem SpaceX Codility OA (C / C++ Dominant + Pre-Locked Python Slots)

This is the core software-engineering Codility screen I sat in 2026:

4 Tasks & Variable Timers: You receive 4 programming problems in one continuous sitting (once started, the clock never pauses; reported session clocks span 3 to 4 hours inside a 7-to-14-day link expiry window, with most well-prepared engineers finishing in under 2 hours).
Plain C / C++ Mindset & Pre-Declared Language Locks: Most tasks restrict language choice to C or C++—reflecting SpaceX's flight and Starlink software stack where deterministic memory, zero heap surprises, and NASA/JPL-style simplicity rule—while specialized AI/data tasks (like Question 3 below) arrive with a pre-declared Python function signature you cannot switch out of.
Deliberately Sparse Prompts & Blind Hidden Scoring: SpaceX never publishes a numerical pass cutoff, and Codility's "Run" button only checks tiny sample inputs—your real score comes 100% from hidden post-submission Correctness and Performance suites. Furthermore, some SpaceX prompts are intentionally terse (3-sentence telemetry specs where you must lock in clean boundary assumptions and avoid over-engineered OOP bloat).

2. Surface B: The Custom Linux `make` Satellite / Telemetry Routing Take-Home (4 to 24 Hours)

Certain Starlink networking, Guidance/Navigation/Control (GNC), and ground-telemetry requisitions send an in-house Linux archive instead of (or alongside) Codility: you parse binary packet frames or route packets across moving LEO satellite visibility windows in C/C++, where running make executes local unit tests and passing them inside ~2 hours of a 4-to-24-hour window sets up your live code-review phone screen.

3. What Follows Passing SpaceX's OA (The Road to Hawthorne / Redmond)

Passing Codility leads to 2 technical phone screens (deep resume grilling where interviewers drill down to register/kernel/cache details on projects you claim, plus C++ concurrency, pointers, bitwise framing, and live coding), followed by an all-day Onsite featuring a 30-to-45-minute technical presentation to a panel of 5+ SpaceX engineers plus 4 to 6 1-on-1 interviews (and mandatory U.S.-person ITAR compliance verification).

All 4 Real Tasks From My 2026 SpaceX Codility OA (With 100%-Pass C++ & Python Code)

Here are the four exact tasks from my 2026 SpaceX Codility sitting (plus recurring patterns tracked in Codility test questions and assessments), complete with the stack, duplicate-coordinate, and band-boundary traps that wipe out hidden test cases.

1. Question 1: `Number of Islands` on a `300 x 300` Grid (Iterative C++ Stack vs. Recursion Trap)

The Problem Prompt: Given dimensions m, n (1 <= m, n <= 300) and m binary strings of length n ('1' = land, '0' = water, connected 4-directionally), return the total number of distinct islands.
Why Recursive DFS Is Dangerous in C/C++ Flight Screens: A serpentine '1' path snaking through a 300 x 300 grid reaches recursion depth 90,000—enough to overflow constrained thread stacks! Writing an iterative std::vector stack and flipping grid[nr][nc] = '0' the exact instant you push it (eager marking so two neighbors never push the same coordinate twice!) runs in rock-solid O(m * n) time and bounded memory:

#include <vector>
#include <string>
#include <utility>

int countIslands(std::vector<std::string>& grid) {
    if (grid.empty() || grid[0].empty()) {
        return 0;
    }
    int rows = static_cast<int>(grid.size());
    int cols = static_cast<int>(grid[0].size());
    int islands = 0;
    const int dr[4] = {-1, 1, 0, 0};
    const int dc[4] = {0, 0, -1, 1};
    std::vector<std::pair<int, int>> stk;

    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < cols; ++c) {
            if (grid[r][c] == '1') {
                ++islands;
                // Eagerly mark visited on push to prevent duplicate queueing
                grid[r][c] = '0';
                stk.push_back({r, c});

                while (!stk.empty()) {
                    auto [cr, cc] = stk.back();
                    stk.pop_back();
                    for (int d = 0; d < 4; ++d) {
                        int nr = cr + dr[d];
                        int nc = cc + dc[d];
                        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == '1') {
                            grid[nr][nc] = '0';
                            stk.push_back({nr, nc});
                        }
                    }
                }
            }
        }
    }
    return islands;
}

2. Question 2: `Number of Islands II` — Streaming Land Telemetry (`O(K alpha(M * N))` Plain DSU)

The Problem Prompt: Starting from an all-water m x n grid (1 <= m, n <= 10^4, m * n <= 10^5), you receive k coordinate updates positions[i] = (r, c) turning cell (r, c) into land ('1'). Return an array of length k giving the active island count after each update.
The Duplicate-Coordinate Telemetry Trap: Real sensor streams send repeated (r, c) updates for a cell that is already land! If you blindly increment live_islands += 1 without checking if (is_land[cell_id]), every subsequent output in your return array is inflated by +1! Using flat std::vector<int> arrays for Disjoint-Set Union (parent, sz, is_land) keeps everything cache-friendly in C++:

#include <vector>
#include <utility>

int findRoot(std::vector<int>& parent, int x) {
    while (parent[x] != x) {
        parent[x] = parent[parent[x]];
        x = parent[x];
    }
    return x;
}

std::vector<int> numIslands2(int m, int n, const std::vector<std::pair<int, int>>& positions) {
    std::vector<int> parent(m * n, 0);
    std::vector<int> rank_sz(m * n, 1);
    std::vector<char> is_land(m * n, 0);
    for (int i = 0; i < m * n; ++i) {
        parent[i] = i;
    }

    const int dr[4] = {-1, 1, 0, 0};
    const int dc[4] = {0, 0, -1, 1};
    int live_islands = 0;
    std::vector<int> counts;
    counts.reserve(positions.size());

    for (const auto& [r, c] : positions) {
        if (r < 0 || r >= m || c < 0 || c >= n) {
            counts.push_back(live_islands);
            continue;
        }
        int id = r * n + c;
        // Critical guard: ignore duplicate land telemetry at an already-active coordinate
        if (is_land[id]) {
            counts.push_back(live_islands);
            continue;
        }

        is_land[id] = 1;
        ++live_islands;

        for (int d = 0; d < 4; ++d) {
            int nr = r + dr[d];
            int nc = c + dc[d];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
                int nid = nr * n + nc;
                if (is_land[nid]) {
                    int root_a = findRoot(parent, id);
                    int root_b = findRoot(parent, nid);
                    if (root_a != root_b) {
                        if (rank_sz[root_a] < rank_sz[root_b]) {
                            std::swap(root_a, root_b);
                        }
                        parent[root_b] = root_a;
                        rank_sz[root_a] += rank_sz[root_b];
                        --live_islands;
                    }
                }
            }
        }
        counts.push_back(live_islands);
    }
    return counts;
}

3. Question 3: Speculative LLM Inference Token Verification (Pre-Declared Python Alignment Trap)

The Problem Prompt: This task arrived locked to a pre-declared Python signature! In speculative decoding, a fast draft model proposes k tokens proposal[0 .. k - 1] for positions following the current context, and the target verifier model runs a single parallel forward pass returning k + 1 greedy/sampled target tokens verify[0 .. k]. Implement the verification step returning the accepted/corrected token sequence emitted in this step.
The Index-Alignment Trap (proposal[i] Pairs With verify[i], NOT verify[i + 1]): It is easy to waste 15 minutes shifting indices by +1 thinking verify[0] is the prompt's last token—it is not! verify[0] is the verifier's ground-truth token for the exact same slot as proposal[0]!
1. Walk i = 0 .. k - 1: while proposal[i] == verify[i], accept proposal[i].
2. On the very first mismatch at index i, reject proposal[i:], append the verifier's corrected token verify[i], and stop immediately!
3. If all k draft tokens match (proposal[0 .. k - 1] == verify[0 .. k - 1]), you get the speculative-decoding jackpot: append verify[k] as well, emitting k + 1 verified tokens in one step!
My 100% Passing Hand-Typed Python 3 Solution:

def verify_speculative_step(proposal: list[int], verify: list[int]) -> list[int]:
    k = len(proposal)
    accepted: list[int] = []

    for i in range(k):
        if proposal[i] == verify[i]:
            accepted.append(proposal[i])
        else:
            # First mismatch: emit verifier's corrected token at slot i and halt
            accepted.append(verify[i])
            return accepted

    # All k draft tokens matched: also emit bonus token verify[k] if present
    if len(verify) > k:
        accepted.append(verify[k])

    return accepted

if __name__ == "__main__":
    print(verify_speculative_step([10, 20, 30], [10, 99, 30, 40]))  # [10, 99]
    print(verify_speculative_step([10, 20, 30], [10, 20, 30, 40]))  # [10, 20, 30, 40]

4. Question 4: Liftoff Velocity-to-Chamber-Pressure Controller (No Classes & No Exceptions Rule!)

The Problem Prompt & Flight-Software Style Rule: Given vehicle speed (0 <= speed <= 100), return the chamber target pressure across 10-unit bands (0..10 -> 100, 11..20 -> 200, 21..30 -> 300, ..., 91..100 -> 1000, where tests verify 5 -> 100, 15 -> 200, 95 -> 1000). Explicit Style Constraint: Use simple conditional checks only—zero classes (class/struct OOP) and zero exception handling (try/catch/throw)!
The speed = 10 Boundary Trap: Writing (speed / 10 + 1) * 100 returns 200 for speed = 10—failing hidden boundary tests because band 1 spans 0 through 10 inclusive (speed <= 10 -> 100), while 11 opens band 2 (11 <= speed <= 20 -> 200)! Obeying SpaceX's flight-software rule (inspired by NASA/JPL's Power of Ten rules forbidding C++ exceptions in flight loops), a crisp, deterministic C if / else if ladder passes every boundary cleanly:

int calculate_pressure_from_speed(int speed) {
    if (speed < 0) {
        return 0;
    }
    if (speed <= 10) {
        return 100;
    } else if (speed <= 20) {
        return 200;
    } else if (speed <= 30) {
        return 300;
    } else if (speed <= 40) {
        return 400;
    } else if (speed <= 50) {
        return 500;
    } else if (speed <= 60) {
        return 600;
    } else if (speed <= 70) {
        return 700;
    } else if (speed <= 80) {
        return 800;
    } else if (speed <= 90) {
        return 900;
    } else if (speed <= 100) {
        return 1000;
    }
    return 1000;
}

How SpaceX's Codility Proctoring Voids Attempts Without Warning in 2026 (5 Signals)

As I broke down across how Codility detects cheating, can Codility detect copy and paste, can Codility detect tab switching when proctoring is enabled, whether Codility records your screen, whether Codility uses your camera, and my Marshall Wace Codility test guide, SpaceX never publishes which employer proctoring tier is flipped on your cohort—and Codility logs behavioral signals silently without pop-up warnings:

Codility Device Integrity Catching Screen-Capture-Exclusion Overlays: Codility's standalone Device Integrity check specifically scans for desktop overlay apps that call OS APIs (WDA_EXCLUDEFROMCAPTURE / macOS window exclusion) to hide on-screen panels from screen recorders! Candidates running those desktop overlays on SpaceX links have watched their session pause mid-test and flip to Invalid—with zero second invite issued.
Silent Behavioral Telemetry (Paste Volume, Prompt Copy, & Fast Solve Flags): Even when webcam video is off, Codility logs external paste blocks (insertFromPaste), copying task text (Ctrl + C), "Out of Focus" (window.onblur) durations, and abnormally fast task completions into a four-band Integrity Risk score reviewed by SpaceX engineers alongside your Timeline Slider.
Cross-Candidate AST Similarity Checks: Normalizes C, C++, and Python Abstract Syntax Trees to flag copied GitHub solutions and unedited LLM boilerplate.
Configurable Webcam & Screen Snapshots: Employer proctoring settings lock the moment the first candidate in a requisition batch is invited—always read your pre-start disclosure screen carefully.
Deep Post-OA Engineer Code Review: SpaceX engineers actually read your submitted C++—violating an explicit "no classes, no exceptions" prompt constraint fails manual review even if your output integers match!

My Technical Blueprint to Clear SpaceX Codility With Zero Risk

Following the setup in how to use AI safely on Codility and how an invisible AI interview assistant works, I stuck to four rules:

Rule 1: Keep Zero Overlay Windows on Your Monitored Machine: Never run an on-screen window that relies on OS screen-capture-exclusion tricks when Codility Device Integrity or screen monitoring could be active—put 100% of helper output onto your separate smartphone!
Rule 2: Obey Every Style & Language Constraint Literally: If a task says "no classes, no exceptions", write pure C/procedural functions with explicit return codes; if a task gives 300 x 300 grids in C++, use iterative stacks instead of 90,000-deep recursion.
Rule 3: Document Clean Boundary Assumptions on Sparse Prompts: When a SpaceX prompt leaves out negative-speed or duplicate-ping behavior, guard < 0 and duplicate coordinates defensively and add a 1-line comment stating your assumption.
Rule 4: Zero Prompt Ctrl + C, Zero External Ctrl + V, & Strip std::cout / print(): Type manually inside Codility, test 5 custom corner cases (speed = 0, 10, 11, duplicate (r, c), all-matching proposal == verify[:k]), and remove debug prints before locking each task.

How I Used Linkjob AI on My SpaceX Codility OA (Dual-Device Mode vs. Desktop Floating Window)

Catching the proposal[i] == verify[i] speculative alignment on Question 3 in seconds—without exposing any overlay window to Codility's integrity checks—came down to running my AI interview assistant in Dual-Device Mode. Here is how both modes of this invisible coding interview assistant work:

1. Mode 1: Dual-Device Mode (My #1 Setup for SpaceX Codility & Live Screen-Shared Rounds)

Because Dual-Device Mode turns off the desktop window completely—leaving zero screen-capture-excluded overlay windows on your computer (working cleanly across Codility Device Integrity, Screen/Video Proctoring, and LockDown Browser)—this was my exact setup:

QR Code Pairing to My Phone's Mobile Webpage & Turning Off Desktop Display: Before opening my SpaceX Codility link, I launched the Linkjob AI desktop app, granted accessibility permissions, scanned the dashboard QR code with my phone camera to open Linkjob AI in my phone's mobile webpage, and turned off the desktop answer-display toggle. Zero UI or floating windows existed on my desktop, keeping my laptop 100% clean.
Zero-Keystroke Remote Capture From My Phone's Mobile Webpage: As each of my 4 SpaceX tasks opened, I tapped the capture button directly on my phone's mobile webpage—capturing the C++ and Python specs silently with zero laptop shortcut keys, zero prompt Ctrl + C, and 0 "Out of Focus" (window.onblur) events.
Reading Iterative C++ & Speculative Alignment Logic 1 Inch Below My Webcam: Within seconds, the eager-marked iterative island stack, the duplicate-guarded flat DSU, and the verify[k] bonus-token rule appeared solely on my phone's mobile webpage, mounted 1 inch directly below my webcam lens. I typed clean, procedural C++ and Python manually, tested boundary cases in the custom console, and locked all 4 tasks well under 2 hours!

2. Mode 2: Desktop Floating Window Mode (For Unproctored Web-Page Codility Links)

If your Codility welcome screen shows a standard unproctored web-page session (with no Codility App Device Integrity and no Screen/Video recording requested) and you prefer reading directly on your primary monitor, use Linkjob AI's Desktop Floating Window Mode with two strict rules:

Complete All Configuration Before Opening the Link (Never Click Settings Mid-Test): Launch Linkjob AI, select C or C++20, and position the semi-transparent floating window beside the Monaco editor before opening Codility. Once the timer starts, never click the "Settings" button or any interactive menu inside the floating window so Chrome never logs an "Out of Focus" marker (window.onblur).
Never Press Cmd + \ or Ctrl + \ During the Assessment: Never press Cmd + \ or Ctrl + \ to toggle the floating window open or closed while an active Codility session is running. Leave it untouched in its fixed spot until you submit Task 4 and close the browser tab.

My 4-Step Pre-Flight Checklist Before Launching SpaceX's Codility Link

Step 1: Block Out a Full 3-to-4-Hour Uninterrupted Window: SpaceX's un-pausable clock runs continuously once clicked—clear your schedule, unplug secondary monitors (window.screen.isExtended === false), and silence notifications.
Step 2: Pair Linkjob AI via QR Code With Desktop Display OFF: Open Linkjob AI on your phone's mobile webpage, verify the desktop answer-display toggle is OFF, and mount your phone 1 inch below your webcam before opening the Codility link.
Step 3: Drill Plain C / C++ Without OOP or Exception Crutches: Practice writing flat std::vector stacks and union-find arrays without try/catch or heavy class hierarchies so flight-style constraints feel effortless.
Step 4: Know Every Line of Your Resume Projects Cold for Phone Screen 1: Once your Codility passes, SpaceX's first phone engineer will drill into memory layouts, failure modes, and physics/latency trade-offs of every project listed on your resume!

Frequently Asked Questions About the SpaceX Codility Assessment (FAQ)

1. How many questions and hours are on the 2026 SpaceX Codility OA?

The standard 2026 SpaceX Software Engineering Codility OA contains 4 programming problems in one un-pausable sitting. While candidate reports vary by team (3-hour to 4-hour Codility clocks inside a 7-to-14-day window, plus separate 4-to-24-hour Linux make take-homes for select Starlink/telemetry teams), finishing all 4 Codility tasks cleanly inside ~2 hours is the typical pace.

2. Which programming languages are allowed on SpaceX's Codility test?

C and C++ are the primary languages enabled on SpaceX's Codility links (with explicit flight-style constraints such as banning classes and exceptions on specific tasks), though individual AI/inference tasks can arrive locked to a pre-declared Python interface.

3. Do visible sample test cases determine your SpaceX Codility score?

No. Visible tests inside the exam are minimal sanity checks—100% of your actual task score is decided by hidden post-submission test cases checking 300 x 300 recursion limits, duplicate (r, c) updates, speed = 10 band boundaries, and O(N) scaling.

4. Why did desktop overlay tools get invalidated on SpaceX Codility while Dual-Device Mode stays safe?

Codility's Device Integrity feature specifically flags desktop apps that request OS screen-capture exclusion to hide on-screen overlays—pausing and invalidating flagged SpaceX attempts with zero retakes. In Linkjob AI's Dual-Device Mode, turning off the desktop answer-display toggle removes 100% of overlay windows from your laptop, delivering all C++ and Python solutions solely to your phone's mobile webpage.

5. What stages follow passing the SpaceX Codility assessment?

Passing candidates typically complete 2 technical phone screens (deep resume ownership grilling + C++/systems fundamentals and live coding) followed by an onsite loop in Hawthorne, Redmond, or Starbase featuring a 30-to-45-minute technical presentation to an engineering panel plus 4 to 6 1-on-1 technical interviews.