Inspiration
I lecture computing at Northumbria University London. Each module starts with assignment brief, starter code, test runs, and expected solution, followed by all cohort submissions and providing student s with insightful and meaningful feedback.
Codex is genuinely good at the first half. The question I kept turning over was whether it could help with the marking too, without handing my academic judgment to a model. That's the line I didn't want to cross. Codex Classroom is my attempt at putting Codex where it earns its keep and keeping the lecturer in charge of the mark.
What it does
You describe an assignment in plain English. Codex Classroom produces the whole package:
- Student brief and learning outcomes
- Starter repo
- Public tests for students and hidden tests only lecturers see
- Weighted rubric
- Reference solution
- Lecturer notes
- A clean student ZIP with the private material stripped out
When a submission comes in, it runs the tests, collects the evidence, maps it to the rubric, calculates a provisional mark, and drafts feedback. You then read the evidence, edit the feedback, adjust the mark with a logged reason, and approve. Nothing goes final without a human clicking approve.
It also flags patterns across a cohort ("seven students all failed the same edge case") and turns that into a suggested teaching action for next week.
How we built it
Next.js, React, TypeScript. The interesting bit is that it isn't one big prompt.
Assignment generation runs through five stages: Assignment Designer, Repository Builder, Test Designer, Rubric Designer, and a Consistency Reviewer that checks the whole package agrees with itself. Evaluation is deliberately split the same way. Test evidence first, then rubric mapping, then the score, then the feedback prose. The feedback is written last on purpose. A well-written explanation cannot decide a student's mark; only the rubric can.
Zod handles runtime validation. JSZip does archive inspection and student-package generation. Recharts for the cohort analytics. Vitest for the domain and security tests, Playwright for the full lecturer journey. There's an OpenAI provider for live generation and a deterministic demo path so judges can walk the whole thing without needing an API key.
Challenges we ran into
- Getting educators to trust an AI marker is not a UI problem.
- If the model can talk itself into a mark, the marks are worthless. The solution was sequential separate the stages, make the score depend only on rubric marking criteria, and generate feedback after the score, never before.
- Security, student repos are untrusted input. The MVP does not execute anything a student uploads on the app server, and every ZIP gets inspected defensively for path traversal, oversized archives, disallowed files, and any accidental exposure of hidden tests or reference solutions.
- Keeping the parts of an assignment in sync was harder than expected. A polished brief is useless if the tests, rubric, and starter measure different things. The Consistency Reviewer catches this before anything ships.
- The last challenge was a demo that always works. The whole flow runs on deterministic data so the judges get the same experience whether the API is up or not.
Accomplishments that we're proud of
The thing I care about most is that this is the full loop, not a party trick. You start with "I want to teach students about dictionaries" and end with a signed-off mark for a real submission, cohort insights included.
The lecturer stays in charge the whole way through. Provisional scores are visibly provisional. Mark overrides require a reason. Approval is an explicit action, not a checkbox buried in a settings menu.
Also worth calling out: the split between public and hidden materials, the non-executing ZIP inspection, reproducible demo evaluations, evidence-grounded feedback, and test coverage on the security boundaries.
What we learned
Responsible AI in education is mostly an architecture problem, not a prompt problem. Once evidence and interpretation are separated, everything is easier to inspect, argue with, and fix. Small structured schemas beat one giant prompt.
Human oversight has to be baked into the interaction. If a lecturer cannot see the evidence, edit the feedback, and record why they moved a mark, "human in the loop" is just marketing copy.
The last one surprised me. The same rubric evidence that produces a mark also tells you what your cohort did not learn. Seven students missing the same criterion is not a marking event; it is a teaching event.
What's next for Codex Classroom
Getting from a demo to something a university could actually run:
- Isolated containers to safely execute student code
- GitHub Classroom and repo import
- LMS integration and grade pass back
- Persistent storage, auth, institutional roles
- Anonymous marking and second-marker workflows
- Assignment versioning and resubmission diffs
- Full audit trails on generation, evaluation, and approval
- More languages beyond the current set
- Cohort-to-cohort teaching insights
- Accessibility testing
The goal is not to replace the lecturer. It is to give them their evenings back and let students get feedback that actually explains what they got wrong.
Log in or sign up for Devpost to join the conversation.