KAUSTAcademy/AutoGrader_Introduction_to_AI

Introduction to AI — Practical Exam Grading Dataset (Stage 2)

1,038 anonymized student submissions to a university-level practical AI exam, each independently graded by two teaching assistants, plus the rubric and the instructor reference solutions.

It is the second exam of Where LLM Graders Succeed and Break: Evidence from Two Computer-Science Exams. The paper's 162 grader configurations on this exam, the graders that produced them and the analysis code live in the project repository, alongside the Computer Vision exam (KAUSTAcademy/AutoGrader_Computer_Vision); this folder is the data itself.

The dataset was built to test how sensitive LLM graders are to the prompt they are given — specifically, what happens when an instructor adds a plausible "be strict" instruction to an otherwise well-behaved grading prompt.

What is here

path	contents
Practical_AI_exam_grades.csv	ground truth: two TA grades per student, per question and total
submissions_extracted/<n>/Q{1,2,3}.ipynb	the anonymized student notebooks
Solutions/	instructor reference solution per question
stage_2_rubrics_ta.md	the marking scheme the TAs graded against
few_shot_examples.json	two worked examples per question for the few-shot runs (IG18, IA201): student code with the IG08 model's (gemini-3.1-pro-preview) score, bonus and reasoning, not TA marks

Students are identified only by a number (1–1038) that is stable across every file. Notebook submissions_extracted/2/Q2.ipynb belongs to the student in row Number == 2 of the grades CSV.

The exam and its scale

Three questions: Q1 tabular regression (predict food delivery time), Q2 PyTorch (predict age from face images), Q3 classification (find the most predictive feature in an anonymized dataset).

Marks come from the rubric's task tables, not its header totals — the two disagree in the distributed PDF, which is preserved here as stage_2_rubrics_ta.md:

question	base	bonus
Q1 Regression	23	3
Q2 PyTorch	14	3
Q3 Classification	19	3

Two instructor corrections were issued by email during grading, both affecting Q3 only (Part 1 dropped a task and became 2 marks; Part 4 dropped a task and became 5). Both are folded into the rubric file and marked ⚠.

Ground truth quality

Every student is graded by two TAs, so the dataset carries its own noise floor:

statistic	value
floor: TA-vs-TA mean absolute difference (totals)	5.13 (95% bootstrap CI 4.80–5.48)
inter-TA correlation (totals)	0.871

The floor is ~8% of the ~65-point scale. An AI grader's mean absolute error against the TA average is read against 5.13, the distance between the two TAs, not against zero.

Anonymization

Student names, ID numbers, emails, and submission links are absent. Notebooks were rebuilt from scratch keeping only code cells: markdown cells, outputs, execution counts, and all per-cell metadata were dropped, so Colab executionInfo blocks (which embed a Google account name and user id) do not survive. Remaining identifiers inside code — names in variable names or comments, emails, ID numbers, phone numbers, filesystem usernames — were replaced with ANON (identifier-safe) or [REDACTED]. One identifier is kept on purpose: the exam-data download line in the notebooks, the solutions and few_shot_examples.json names the course's Kaggle dataset (its owner's handle and the q{1,2,3}-ka-ai-2026 slugs), because that is the text the published runs graded.

Scrubbing was verified two ways: an exhaustive scan against the full roster (every student and TA name, email and ID, plus generic email/ID/phone patterns and notebook-format regressions), and an LLM review of all ~25k comment and string literals looking for identifiers the roster could not know about. The second pass is what caught a reference to an instructor by first name and one student who had loaded the exam data from a personal account.

TAs appear only as pseudonyms (TA_1, TA_2, …). One slot carries the composite id TA_49+TA_50: two TAs share that slot, which covers 18 students. The pseudonym-to-person mapping is not published, so grading behaviour cannot be attributed to any individual.

The grader in the project repository is the script that produced the published runs, prompt included, and the notebooks here are the ones it graded.

Known gaps, stated plainly

• 24 students from the original cohort are absent: they uploaded nothing, an unreadable archive, or files that were not the exam. The remaining 1,038 are numbered contiguously.
• 75 students are missing a notebook for at least one question (96 notebooks in all: 4 for Q1, 44 for Q2, 48 for Q3) — they did not submit that question. An absent Q<n>.ipynb means exactly that, and the grading code scores it 0.
• The rubric's header totals contradict its own task tables in all three questions. This is preserved rather than corrected; it is part of what a real grading prompt has to cope with.
• 29 TA per-question grades (on 27 students) exceed the question's maximum including bonus (Q1 26, Q2 17, Q3 22), and one TA total (68.45) exceeds 65.
• Two TA grades awarded credit for a question the student never submitted (8.0 and 10.0, each contradicted by the paired TA's 0). Both were set to 0 and the totals recomputed: ground truth that credits work no grader can see would penalise every grader, human or machine.
• Nine rows record 0.0 for exactly one TA while the paired TA awarded real marks: ungraded slots stored as zeros. They are kept; without them the floor is 5.09 (95% CI 4.76–5.42) instead of 5.13, and no conclusion in the paper changes. A further nine rows carry 0.0 from both TAs: their notebooks are the blank exam template or nearly so, so these are genuine zero-mark papers, not recording errors.

The LLM runs

The paper grades this exam with 162 configurations: 132 over 17 open-weights models and 30 with closed models (23 Gemini, 6 OpenAI, 1 Anthropic), one workbook per configuration in the project repository's introduction_to_ai_results/results/, holding the AI score, bonus and reasoning per question alongside the TA columns. The core comparison runs every open-weights model twice over the full cohort with an identical prompt except for its leading persona preamble:

• neutral — "You are a strict but fair teaching assistant."
• strict — "You are a HARSH teaching assistant. Award the MINIMUM defensible score for any task that is incomplete, buggy, or deviates from the rubric. Never give partial credit if the task does not run correctly."

Everything else is held fixed: reference solution included, per-task breakdown requested, no chain-of-thought, temperature 0, one sample per question. The other personas are STRICTNESS_PRESETS in introduction_to_ai_grade_with_local.py, and build_prompt() in the same file assembles the full prompt around them.

behaviour classes: refusal (≥90% of students zeroed, awarded-total std < 0.5), near-refusal (≥90% zeroed but still varying), collapse (MAE ≥ 15.7, i.e. 3.07× this exam's floor, the multiple the Computer Vision exam's MAE ≥ 8 fixes, while still discriminating between students), graded otherwise.

Reproducing

The grading and analysis code lives in the project repository, which expects this folder at introduction_to_ai_dataset/ beside it:

# serve a model with vLLM, then:
python introduction_to_ai_grade_with_local.py --all \
  --model <hf-model-id> --api-base http://localhost:8000/v1 \
  --max-output-tokens 8192 \
  --with-solution --no-reasoning --with-breakdown \
  --strictness strict --temperature 0.0 --runs 1 \
  --tag IA02_m-<model_tag>_sol1_gd0_rs0_bd1_str-strict_t00_n1

python analysis/introduction_to_ai_run_analysis.py   # MAE, CI, behaviour class per run

introduction_to_ai_submit_persona_sweep.sbatch is the SLURM launcher: an array job, one task per persona (--array=0,1 gives the neutral+strict pair). STUDENTS=1-5 turns it into a smoke run that writes to introduction_to_ai_results/smoke/ instead of results/ and leaves the run tracker alone. Never point two runs at one output workbook — the grader holds the whole workbook in memory and rewrites it after every question, so two writers silently destroy each other's grades.

The published runs used vLLM 0.19.1. Grading is not bitwise reproducible: generation is unconstrained, and JSON is parsed leniently.

Licence and intended use

Released under CC BY-NC 4.0 (Creative Commons Attribution-NonCommercial 4.0 International): use, share and adapt it for non-commercial purposes with credit to the source. The student work was contributed with the course instructors' permission and is released for research on automated grading. Do not attempt to re-identify students or TAs.

Citation

@misc{habibullah2026llmgraderssucceedbreak,
      title={Where LLM Graders Succeed and Break: Evidence from Two Computer-Science Exams},
      author={Ali Habibullah and Yazan Alshoibi and Mohammad Alshiekh and Salman Khan and Naeemullah Khan},
      year={2026},
      eprint={2609.29333},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2609.29333},
}