CourseSight

Inspiration

Every Lehigh student lives in CourseSite, our Moodle-based course management system, and almost everyone has the same complaints:

• Grades are wrong for most of the semester. CourseSite shows a raw, unweighted points average. Professors usually recalibrate to the syllabus weights only at the end, so a student can sit at a "B−" all semester that's really a B.
• Deadlines live in a separate tab from the courses they belong to.
• Announcements hide behind a button inside each course.
• Each course page is a wall of 15 identical weekly accordions.
• There's no way to book office hours, and questions get pushed out to Piazza.

Professors have their own version of the problem: setting up weighted grades is tedious, and they have little visibility into where students are struggling. Most homework isn't even submitted through CourseSite. It's handwritten or done on McGraw Hill Connect.

We wanted a course site that answers two questions on one screen: "What do I need to do?" and "How am I actually doing?"

What it does

CourseSight is a reimagined CourseSite with two equally developed experiences.

For students

• One-screen home: every deadline across all courses, color-coded by urgency (Todoist-style: red today, bold orange within ~30 hours, yellow this week, green next week). Also announcements in Latest and per-course tabs, grades (hideable), and the week ahead.
• Syllabus-weighted grades, live: the current weighted grade and letter, shown next to the crossed-out number old CourseSite would display. Plus a breakdown by category, the range of final grades still possible, and a "What do I need?" panel for every letter grade.
• A course page that doesn't scroll forever: a horizontal week strip (with dots showing done/missing work) and one focused week split into Learn and Do, with an outline view for the whole semester.
• One-click help: an "I'm stuck" button on every assignment, anonymous discussion tagged by assignment (with "similar questions already asked" shown as you type), and office-hours booking.
• A Google-Calendar-style week/month calendar, color-coded by course with a workload heatmap, plus a personal planner.
• A course assistant chat grounded in the syllabus, schedule and announcements.
• Five themes, including dark mode.

For professors

• Create courses, invite by email, and post assignments that are uploaded here, done on an external site (e.g. Connect), or taken in class.
• A split-view grader with inline PDF/photo/code preview, per-question scores, late-penalty suggestions and keyboard shortcuts.
• Upload the syllabus → AI drafts the grade weights, drop-lowest rules, letter scale and late policy, and sorts every assignment into a category. The professor reviews and confirms, and every student's grade is weighted from then on.
• A "Where students are stuck" digest built from stuck clicks, tagged questions, office-hour notes and per-question averages.

How we built it

• Frontend: React 19 + TypeScript + Vite + Tailwind CSS v4.
• Backend: Express 5 + SQLite (better-sqlite3), with a realistic seeded semester: 2 courses, 54 assignments, submissions, threads and office hours.
• Shared package: API types and the grade engine are shared by server and client through npm workspaces, so the browser can recompute "what do I need?" instantly.
• AI: Claude Sonnet 5.5 via the Anthropic SDK, using structured outputs validated with Zod. Every AI feature is a single call, not an agent, and each has a deterministic offline fallback so the app works without Wi-Fi.

The grade math

The AI never computes grades. It only proposes the weights, and plain, unit-tested code does the rest. Let $G$ be the set of categories with at least one graded item, $w_c$ each category's weight, and $p_c$ the student's average in category $c$ (after dropping the lowest $k_c$ scores). The current grade renormalizes over what's been graded so far:

$$ \text{current} = \frac{\sum_{c \in G} w_c \, p_c}{\sum_{c \in G} w_c} $$

That way a 92% on homework in week 8 reads as 92%, not as a failing grade just because the final hasn't happened. We also compute the lowest and highest final grades still possible, $L$ and $U$ (zero vs. full marks on everything remaining). The average a student needs on remaining work to reach a target $T$ is then

$$ x = \frac{T - L}{U - L} \times 100\% $$

where $x \le 0$ means the grade is locked in and $x > 100\%$ means it's out of reach.

Challenges we ran into

• We can't read most submissions. Homework is handwritten, photographed, or done on McGraw Hill, so "AI analyzes student work" was off the table. Instead we collect cheap, honest signals (one-click "I'm stuck" reports, assignment-tagged questions, office-hour notes, per-question scores) and summarize those. No files are read and no names are sent to the AI.
• Trust. Students won't accept "the AI made up my grade." We kept AI at the edges: it reads the syllabus once, the professor confirms, and deterministic code handles every grade update.
• Defining "grade so far." Ungraded work shouldn't count against you, but missing work should. We treat past-due missing uploads as 0 and submitted-but-ungraded work as still remaining.
• Making the course page calm. It took a redesign to replace the 15-accordion scroll with the week strip and a focused week.
• Demo robustness. We built an offline syllabus parser that extracts the demo syllabi exactly. The seed also shifts every date by whole weeks, so "today" is always week 8 whenever we present.

Accomplishments that we're proud of

• The live moment: a professor uploads a syllabus, confirms, and a student's ACCT151 grade goes from 81.7% (B−) unweighted to 86.8% (B) with a full breakdown.
• Two complete roles: a student can submit, ask, book and plan, and a professor can create, grade, announce and see where students are stuck.
• A unit-tested grade engine (drop-lowest, renormalization, bounds, required score).
• AI that's useful but never load-bearing for correctness, and a demo that survives bad Wi-Fi.

What we learned

• Put AI where judgment is cheap to verify (extracting weights a professor reviews), not where errors are costly (computing grades).
• Sometimes the best data source is just asking. A one-click "I'm stuck" beats trying to parse a phone photo of handwritten homework.
• The right model is often not the biggest. One structured extraction call runs fine on Sonnet, faster and cheaper.
• Designing for students and professors at the same time keeps features honest: every student action had to produce something useful for the professor, and vice versa.

What's next for CourseSight

• Ship it inside Moodle as a theme + plugin, mapping to Moodle's own courses, sections, assignments and gradebook categories.
• Lehigh SSO and roster sync instead of email invites.
• CSV grade import from McGraw Hill Connect and Gradescope.
• Push/email reminders and .ics calendar export.
• Rubric-based grading, and a pilot with a real course to measure whether students check their grades less anxiously and professors spend less time calibrating.

Built With

• claude