Education
The autonomous classroom: scaling technical mentorship with AI
When verification is automated, instructors get their time back for the part of teaching that doesn't scale: judgement, feedback and mentorship.
The part of teaching that scales least is the part that matters most: a person who knows the subject looking at a student’s work and helping them see what to do next. When verification is automated, that time comes back. This post is about what an instructor can do with it, and about the limits that keep the arrangement honest.
The mentorship paradox
Technical courses keep getting larger, and the projects students build keep getting more ambitious. The time an instructor has does not grow with either. Spread across more students and more features, the hours available for one-to-one guidance shrink.
What fills those hours instead is verification. Does the POST endpoint return the right status? Does the layout survive a narrow viewport? Can a user actually log in? These are important questions, and students deserve accurate answers to them. But answering them by hand, one project at a time, is not where an experienced engineer or educator adds the most value.
What “autonomous” means here
An autonomous classroom is not a classroom without a teacher. It is one where the routine verification of student work happens before the instructor opens it, and arrives as evidence rather than as a stack of links.
In Evals.sh, that verification is done by agents. For a deployed project, an agent opens the app in an isolated headless browser, turns your instructions into a test plan, and works through it: clicking, typing, navigating and taking screenshots as it goes. For uploaded project files, an agent explores the code in a single-use workspace and assesses it against criteria such as security, maintainability and test coverage. For written work, assignment grading applies your rubric. Each produces a score with per-criterion reasoning that points back to what was observed.
The word “autonomous” refers to that loop running without supervision. It does not refer to grades being decided without a person.
The pipeline
Here is how a typical project assignment flows when verification is automated. Nothing about the student’s side changes much; what changes is what the instructor receives.
- Students build and deploy to any host that gives them a public URL, and submit the link, or their project files if you are reviewing code.
- You import the submissions into a Group, as a pasted list or a CSV, with one set of instructions for the whole class.
- Agents run each evaluation in the background and write a report per submission: test plan, step log, screenshots and scored criteria.
- You review the class table and open the reports that need attention.
- Students get the report through a shareable link, along with your comments, and iterate.
What office hours become
When a student arrives at office hours having already read a report that shows exactly which step of their signup flow failed, the conversation starts in a different place. “Why doesn’t my login work?” becomes “The report shows my session is lost after a reload. Should I be storing it differently?”
That second question is the one worth an instructor’s time. It opens the door to topics that rarely get airtime when grading is the bottleneck:
- Architecture and trade-offs. Why one state management approach fits this app better than another, and what it will cost later.
- Designing for users. Moving from “it works on my machine” to “it works for the person using it,” including accessibility and error states.
- Explaining decisions. Helping students articulate why they built something the way they did, which is a large part of working on a real team.
- Working with AI tools well. Reviewing generated code critically instead of accepting it, which is now a core professional skill.
The instructor’s role shifts from bug finder to something closer to a lead engineer reviewing a junior colleague’s work: less “this is broken,” more “here is how to think about it.”
Faster feedback, more iteration
Feedback is most useful while the work is still fresh. When review takes weeks, students have usually moved on by the time they hear what went wrong. When an automated first pass can run as soon as submissions close, the loop tightens.
That opens up assignment designs that are hard to support by hand. You can allow a resubmission after the first report and re-run the same Group. You can run a mid-point check so students see where they stand before the final deadline. You can ask for more ambitious projects, because the cost of verifying them no longer scales directly with your evenings.
Students tend to respond to concrete, prompt feedback by trying again. That is the behaviour a course should be encouraging.
Guardrails
Automation in assessment needs clear limits. These are the ones we think matter:
- A person owns the grade. The agent’s score is a first pass. Low, borderline and surprising results should be reviewed before they count.
- Every score shows its evidence. If a student disputes a result, both of you should be able to look at the step log and screenshots and see what happened.
- Submissions are data, not instructions. Text on a student’s page cannot redirect the agent; only your evaluation instructions can.
- Student work is not used to train models. Code and projects are processed to produce the evaluation and nothing else, and uploaded code is copied into single-use workspaces that are deleted when the job ends.
- Instructions are the instructor’s job. The quality of automated verification depends on how clearly the brief describes the expected behaviour. That is a skill worth investing in.
None of this removes the human from teaching. It removes the repetitive checking that crowds teaching out. What is left is the part only a teacher can do, and more time to do it. To see how the verification step works in detail, read how Evals.sh works.