AI in the Workflow, Not on the Podium

The problem

As enrollment grows, the bottleneck in a technical course stops being content and becomes feedback.

Grading, discussion facilitation, and student communication consume the hours that should go into teaching and improving the course. Worse, quality degrades exactly where it matters most: at scale, across multiple sections and multiple instructors, the same syllabus produces wildly uneven feedback. One student gets three paragraphs of specific, actionable commentary. Another gets a score.

The obvious response — point a language model at the submissions — fails for a reason that has nothing to do with model quality. Instructors will not adopt a system that grades on their behalf, and they are right not to. Academic judgment is the job. Any tool that takes it away is either ignored or, worse, used carelessly.

So the design problem was not "can AI grade this." It was: how do you remove the mechanical labor from grading while leaving every actual decision with the instructor — and make that guarantee visible enough that they believe it?

What I built

A production web platform integrated directly with the institution's LMS, removing the highest-volume, lowest-leverage instructor work while keeping the instructor as the decision-maker on every output.

Rubric-aligned grading

Student submissions are evaluated against the instructor's own rubric, criterion by criterion, producing a recommended score, a rationale for each criterion, and student-facing feedback.

Scoring and feedback writing run as separate passes. The grade is decided on evidence first, and only then is a narrative written around it. Doing it the other way around — writing the commentary and letting the score follow — produces fluent text that rationalizes whatever number appeared first.

In-context annotation

Feedback is anchored to the exact location it refers to: a specific passage in a PDF or document, a specific line in a code submission. Not a detached summary comment at the end.

This was the hardest engineering problem in the project. Mapping model-generated feedback back to precise coordinates in a rendered PDF, and to exact line numbers in source code, required custom text-model, quote-position, and line-anchoring layers with multi-tier matching and graceful degradation when a quote cannot be located. A comment that lands in the wrong place is worse than no comment at all, so the failure mode had to be "this annotation is unplaced" rather than "this annotation is confidently wrong."

PDFs, Word documents, spreadsheets, CSVs, images, Jupyter notebooks, and roughly fifty source-code file types are handled natively, with syntax highlighting and cell-level rendering where appropriate.

Discussion, announcements, and triage

• Draft instructor replies generated with configurable tone and length, refined through a chat interface, graded against participation rubrics, and posted back to the LMS.
• Context-aware announcements drafted from actual course items — upcoming assignments, quizzes, discussions — and reviewed before publishing.
• An instructor dashboard showing what needs attention across courses: ungraded submissions, unanswered discussion posts, announcements awaiting response.

The design principles that made it adoptable

These were the constraints that decided whether the platform got used at all.

The instructor is always the decision-maker. Nothing reaches a student without explicit approval. Every AI output is a draft. Every annotation can be added, edited, or removed before publication.

Low-confidence work is flagged, not hidden. The grading model reports its own confidence and raises a human-review flag when evidence is ambiguous, incomplete, or requires instructor judgment. A system that is uniformly confident is a system that cannot be trusted anywhere.

Feedback must be evidence-bound. The system is constrained to ground every score and comment in specific, quotable evidence from the submission. It is explicitly prevented from inventing requirements, deducting for unstated preferences, or treating a file name as proof of its contents.

The LMS stays the system of record. Grades, comments, and posts write back to the institution's gradebook. The platform is a workflow layer, not a parallel data silo — because a shadow gradebook is an institutional risk, not a feature.

Technical implementation

Next.js and React on a TypeScript codebase, PostgreSQL backing store, serverless infrastructure on AWS. Roughly fifty API routes handle LMS proxying, AI orchestration, document processing, and billing.

LMS credentials are encrypted at rest, and all state-changing requests pass origin validation middleware.

Model selection sits behind per-feature flags, so individual capabilities can be upgraded or rolled back independently as models improve. That is the same "built to be updated" principle applied to the software itself: the parts of a system most likely to change are the parts that should be cheapest to change.

What made it work

The trust constraints were the product. Confidence flags, evidence-bound feedback, mandatory review gates, and full editability were not friction added to a grading tool — they were the reason instructors adopted it. A version without them would have been faster to build and would have sat unused.

Separating scoring from narrative changes the output. Deciding the grade on evidence before writing anything about it is a small architectural choice with a large effect on whether the feedback is honest.

Wrong placement is worse than no placement. Building annotation to fail visibly — unplaced rather than misplaced — mattered more to instructor confidence than raising the match rate would have.

AI belongs in the workflow, not on the podium. The highest-value applications were the repetitive, high-volume tasks standing between instructors and their students: grading mechanics, draft communication, media production. Judgment, relationship, and academic standards stayed with the instructor — by design, and by system constraint.

What transfers

The pattern generalizes to any domain where an expert's judgment is the product and the volume is the problem — claims adjudication, clinical review, underwriting, audit:

1. Separate the decision from the narrative. Decide on evidence, then explain. Never the reverse.
2. Make the model report its own uncertainty, and route low confidence to a human rather than smoothing it over.
3. Bind every output to quotable evidence from the source material, and forbid inventing criteria.
4. Keep the existing system of record. A workflow layer is adoptable; a parallel data store is a governance problem.
5. Design the failure mode. Visibly unplaced beats confidently misplaced.
6. Treat the review gate as the feature, not as overhead to be optimized away later.