Authentic Assessment

The traditional final exam assumes a room, a clock, and a single correct answer. Fully online programs have none of the first two, and generative AI has quietly dissolved the third, so the task is not to defend the old exam but to replace it. The replacement is a summative, capstone-style assessment a student cannot fake: an authentic professional problem, personalized to the learner, where the grade rests on the process and the reasoning rather than a final answer a chatbot could hand back. Traditional exams exist to certify that a student can do the work, and a remote student with a text box and a chatbot can now pass them without demonstrating anything, so the certification no longer certifies.

The answer is not to police AI harder. It is to change what we ask students to do: put them inside an authentic problem tuned to their level and their path, make them gather what matters, make judgment calls, justify each one, and live with the consequences the scenario returns. You cannot paste your way through a well-built simulation, because the graded thing is the reasoning, not a lookup.

Fully online professional and technical programs whose students never come to campus, never meet in real time, and never set foot in a physical lab, and the faculty and subject-matter experts who assess them. It also speaks to instructional designers, assessment designers, and academic leaders weighing how to keep summative assessment valid under generative AI. Everything has to work remotely, in a browser, and the pattern is built to travel across disciplines rather than serve one course.

The design rests on one reusable simulation-assessment pattern, grounded in backward design and constructive alignment: personalize the scenario to the learner, have them perform a real task, and point AI at the assessment itself, as a lab partner, a simulated client, or a scenario engine, so it becomes the thing that makes authentic assessment possible instead of the thing students cheat with. Turned toward the assessment this way, AI stops being the cheating vector and becomes the reviewer who pushes back, the client who reacts, the scenario that adapts in real time.

Each assessment is built as a single-file, no-backend, no-PII web object, and is tested with synthetic-student usability passes before it reaches a learner. The three scenario-based simulations vary what the learner is given from run to run. The capstone is a readiness check and rehearsal rather than a scenario, so it does not vary, and the rehearsal engine it hands off to draws its questions from a pool.

This continues my own scholarship rather than starting a new interest. My master’s research was on personal learning environments, the idea that learning is strongest when it is organized around the individual learner and their own network of tools, people, and goals rather than a one-size-fits-all container. Learner-customized assessment is that same principle carried into how we measure competence: if the learning is built around the person, the proof of it should be too.

The first fully-built proof of the pattern is a suite of summative simulations for a graduate Advanced Data Science course. Each one puts the learner in a real professional decision and grades the reasoning, not a retrievable answer, and each randomizes its scenario on every run, so no two attempts are alike. Open each tab to read what the simulation is and run it inline.

The pattern is built to travel. These are four candidate simulations for fields outside my own, each designed to run entirely in the browser with no physical lab, equipment, or campus visit. Each names the real task, what the student produces, and the part AI plays.

• Browser-based interactives built in HTML, CSS, and JavaScript, so the assessment runs anywhere with no lab, install, or campus visit.
• An AI model over its API for the parts that react and reason: the lab partner, the simulated client, the scenario engine.
• Adobe Illustrator for the scenes and visual system, exported as SVG.
• Evidence-centered design and stealth assessment: competence inferred from what the student does inside the task, not from a final answer.
• Backward design and constructive alignment to tie each scenario to the competency it certifies.
• The leaked feature, the contaminated rows, the true cluster count, and the failing subgroup vary from run to run, so the answer cannot be passed along. Opened with a roster identifier they are seeded per learner instead, which fixes one version per person and lets an instructor reproduce it exactly.
• Published as open educational resources under CC BY 4.0 for reuse across programs.

An assessment that varies per student raises three fair questions: can the instructor reproduce a specific attempt, is the variation tied to who received it, and can a student obtain someone else’s version. Here is where that stands, plainly.

What the demonstrations do today. Each run randomizes the scenario in the browser. Nothing is recorded, nothing identifies the person running it, and there is no seed value to retrieve. That is the right design for an open demonstration, where anyone can try it and no one should be tracked. It is not sufficient for grading, and it is not presented as if it were.

What the graded version requires. Three things, in this order.

1. Derive the seed from the learner, not from chance. The seed is a hash of the roster identifier the institution already assigns, so the same student always receives the same scenario and two students almost never share one. It is deterministic, which means it needs no server and no stored record.
2. Surface the seed at submission. The results screen prints the seed and the learner includes it with their work. The instructor pastes it into an instructor view to regenerate the exact scenario that was graded, which is what makes a disputed grade reviewable.
3. Bind the seed to the person. A short signature computed from the identifier and the seed together is printed alongside it. A learner can copy a classmate’s seed, but the signature will not match their own identifier, so a borrowed scenario is visible rather than hidden.

Deriving the seed from identity also closes a quieter problem: with unseeded randomness, a learner can reload until the scenario resembles one they have already seen solved. A deterministic seed removes the reroll without adding surveillance, which is the trade this whole suite is built around.

Status. Built and working in all three scenario-based simulations: Ridgeline, Segments, and the governance board. Opened plainly each runs as open practice: varied, nothing recorded, nobody identified. Add a roster identifier, as in sim-ridgeline.html?id=jrivera, and that learner’s version is fixed, the seed and signature print on the results brief, and reopening with &seed= regenerates the graded attempt exactly, down to the plotted points. Running a classmate’s seed under your own identifier returns a signature mismatch rather than passing quietly. The capstone has no scenario to seed.

One honest limit: the signature is computed in the browser, so it deters casual seed-swapping rather than a determined attacker who reads the source. Making it tamper-proof means computing it where the learner cannot see it, in the LMS or a small service, which is the correct place for it once this is graded rather than demonstrated. The seed derivation does not change, only where the signature is calculated.

The direction is not idiosyncratic. What follows is my working landscape of real scholarship and real practice, grouped by the argument it supports. The through-line: as AI erodes the validity of the traditional exam, the field is moving toward authentic, personalized, performance-based assessment, and the strongest examples are already online and browser-based.

The graduate data-science suite is built and openly licensed, in review with a subject-matter expert, and not yet delivered to students. The broader pattern is in active development, and I am looking for faculty collaborators in fields outside my own to help develop and test the next simulations.