Skip to main content
Jonathan Andrei
Back to all posts
Jul. 202610 min read

Viva: 91 Full-Mark C Submissions Out of 626 Hide a Defect the Autograder Never Checked

A passing test suite proves a program worked on the inputs the instructor happened to check. It does not prove the student can explain what the program does. Viva closes that gap: GPT-5.6 reads the assignment and proposes an input the test suite never tried, Viva runs the student program and the reference on it, and it only asks the student a question when the two programs disagree. On 626 real C submissions that earned full marks, 91 (14.5%) hide a defect the autograder never checked, and 83 of those (13.3%) fail on an input as simple as `5 5 3`. Not a prediction, a replay: every finding carries a re-runnable command.

OpenAIBuildWeekGPT-5.6OpenAI CodexEducationStatic AnalysisNext.jsTypeScript
I created this post and the Viva project for OpenAI Build Week. #OpenAIBuildWeek

A passing test suite proves a program worked on the inputs the instructor happened to check. It does not prove the student understands what the program does. Viva closes that gap. GPT-5.6 reads the assignment and proposes an input the test suite never tried, Viva runs the student program and the instructor's reference on it, and it only asks the student a question when the two programs disagree. The teacher gets a reteach brief, never a cheating accusation.

Viva teacher brief hero card, large headline reading '91 programs broke' with the 626-submission denominator and the 14.5% rate underneath, and three exercise rows (Maximum of 3, Order 2, Order 3) with their per-exercise counts and rates
The headline number is 91 of 626, not a percentage in a vacuum. Every one of those 91 is a full-mark submission that hides a defect the autograder never checked.

The concrete example

The assignment is print the maximum of three integers. The instructor's three tests are `1 2 3`, `6 2 1`, `-1 3 1`. Not one of them ties, so nothing ever catches the tie. Give the student's program the input `5 5 3` and it prints `3`: both strict `>` branches are false when a and b are equal, so the else prints the third value. The student passed every test and got full marks; they never learned that ties break the pattern.

Viva ledger view showing the row for the Maximum of 3 exercise with a large 226 full-mark submissions count and a red 50 (22.1%) broken column, with the concrete '5 5 3 -> Student prints 3, Reference prints 5' probe underneath
The Maximum-of-3 row alone: 50 of 226 full-mark submissions broken on the tie. The probe is a re-runnable command, not a paragraph.

Why a chat session cannot do this

Paste the code into a chatbot and it will guess whether the code is wrong, and sometimes hallucinate a bug that is not there. Viva never guesses. GPT-5.6 decides only what to test; execution decides whether this submission fails it. A finding is two programs printing different things on the same input, with both outputs shown. That split is the whole design.

  • GPT-5.6 (discovery, Responses API, effort high): reads the assignment spec and the reference solution and proposes edge-case inputs a beginner would plausibly get wrong (ties, zero, negatives, single elements, boundaries). This is the part that generalizes to any exercise and that a hardcoded checker cannot do.
  • Execution (verification): compiles the student program and the reference in a WSL C runner, runs both on each proposed input, and keeps only divergences that reproduce. A cosmetic float-formatting difference (5.0 vs 5.000000) is detected and excluded; only answer-changing divergences count.
  • GPT-5.6 (defense, effort medium): grades the student's typed explanation against that one executed fact, and pushes back if they restate the output instead of tracing the code. Never mentions cheating.
Viva probe detail showing the exact command line invocation (student and reference), the shared stdin, and both stdout outputs side by side with a red pointer at the diverging characters
Not a prediction, a replay. All 215 divergences replayed on an independent rerun. 100%. That is the number that matters after the headline.

The teacher gets a reteach brief, not a cheating accusation

The teacher view organizes the 91 findings by misconception: ties, off-by-one on boundaries, negative-input handling, and a few others. Each misconception carries the count of students affected and one canonical probe. This is a reteach signal (the class systematically missed the tie case), not a per-student accusation.

Viva teacher concept map grouping the 91 findings by misconception, with rows for 'ties', 'boundary off-by-one', 'negative-input handling' and their student counts
The concept map tells the teacher what to reteach on Monday morning, not which student to email tonight.
Viva UI reminder tile explicitly saying it does not detect cheating, does not make an authorship claim, only reports demonstrated understanding of the student's own submitted code
The framing is deliberate. Detection tools become useless the moment students learn to defeat them; a reteach brief remains useful either way.

The student defense flow

The student is asked exactly one question about their own program: on the probe that showed the divergence, what does the code do and why does it print that? GPT-5.6 grades the answer against that one executed fact, constrained to the probe's evidence id. If the student restates the output, the grader follows up asking them to trace the branch that fired.

Viva student defense screen with the concrete probe input, the two outputs, and a textarea asking 'What does your code do on this input, and why?' with a submit button
One probe, one question, no template. The student is asked about their own submission, not the general concept.

The grader's response is validated for the expected evidence id before it reaches the interface. If the model tries to cite a probe it was not shown, or invents a new input, the response is dropped and regenerated. It cannot conjure a new fact about the student's code, only reason over the single executed one, so the follow-up is always grounded in the same divergence the teacher saw.

Viva rendering the follow-up when the student restated the output as an explanation: the grader points to the line of code that actually ran and asks the student to explain why that specific branch was taken
The bluff-catch. Restating the output is not an explanation, and the grader will not accept it as one.

Built in Codex, end to end

Viva was built in Codex using GPT-5.6 (gpt-5.6-sol, gpt-5.6 aliases to it). GPT-5.6 is the engine in two places: the discovery step (src/prober/generator.ts, Responses API, reasoning effort high) and the defense grader (src/viva/grader.ts, effort medium), which is constrained to the one executed probe and validated for the expected evidence id before its response reaches the interface. Codex accelerated the WSL C runner, the batched execution harness, the evidence schema, the divergence categorizer, the benchmark, and the deployed teacher and student flows.

Honest limitations

  • The offline benchmark covers three integer exercises where every proposed input is in-domain and every concept label is correct. It is not a defect rate for the whole corpus. GPT-5.6 discovery extends coverage to the exercises the curated fallback deliberately skips (divisor, average, digit-sum, time-conversion, string exercises).
  • The teacher brief is a product demo generated from public, anonymized corpus results. Production needs LMS integration, accessibility review, consent, and a prospective study with educators and students.
  • Viva reports demonstrated understanding. It is not a cheating detector and never makes an authorship claim.
GPT-5.6 decides what to test; execution decides whether this submission fails it. A passing autograder is not proof of understanding, and a chatbot's guess is not proof of a bug. Viva turns 626 anonymous full-mark submissions into 91 concrete replayable divergences and one small question per student, addressed to their own code, on their own probe, with the grader constrained to the executed fact. That is what an oral exam for code looks like.
Related project

Viva: An Automated Oral Exam for Code. On 626 Full-Mark C Submissions, 91 (14.5%) Hid a Defect the Autograder Never Checked.

View the project