Plagiarism-resistant assignment design reduces copying by making solutions non-transferable, requiring process evidence, and personalizing deliverables. We redesigned eight core assignments in our 200-level Data Structures course (Java, 120 students) and watched overall similarity — measured by our code plagiarism checker — drop from 43% to 7% over two semesters, without changing the syllabus content.
That 7% isn’t zero, and it never will be. Students still copy from the web, still paraphrase with AI, still find the one lab partner who writes everything. But the design changes moved the needle enough that the remaining cases became tractable for detection tools, and the honor-council referrals actually held up.
The problem with generic assignments
Most introductory and intermediate programming courses still hand out the same problems year after year: implement a doubly-linked list, write a quicksort, build a simple shell. When every student in a 120-person section writes identical solutions to identical specifications, the signal a similarity checker picks up is often just the nature of the task, not misconduct.
We saw this firsthand with a classic balanced-tree assignment. The spec was precise, the public API was fixed, and the test harness was identical for everyone. Codequiry flagged 35% of submissions with cross-pair similarity above 70%, but on closer inspection maybe half were students independently writing the same algorithm to the same interface. The real copies and the honest convergence were impossible to cleanly separate. We needed assignments where honest convergence looks different from copying.
Techniques that moved the needle
We didn't invent any of these, but applying them systematically across a full term made the difference.
Personalized test data
Every student gets a unique input set generated from their student ID. The problem statement is the same — say, “compute the longest palindromic substring” — but the string they process is different, so the correct output is different. Copying code verbatim from a friend still produces the wrong answer, which gets caught by the autograder before any similarity check runs.
We built a tiny Python script that all instructors can run to create a JSON file mapping student IDs to test strings:
import hashlib, json
def generate_test_strings(ids, length=1000):
results = {}
base_chars = "abcdefghijklmnopqrstuvwxyz"
for sid in ids:
seed = hashlib.sha256(sid.encode()).digest()
rng = random.Random(seed)
s = ''.join(rng.choice(base_chars) for _ in range(length))
results[sid] = s
return results
We then embedded that string in each student’s submission environment. The autograder checks the computed output against the expected value for that student. A copied solution that hasn't been re-executed with the correct input fails fast.
Process-visible grading
We required three graded intermediate artifacts before final code submission: a design sketch, a first-commit snapshot with unit tests passing on a trivial subset, and a reflection paragraph describing one refactoring decision. Each was worth a small but non-trivial portion of the grade (10% total).
This made it far harder to buy or borrow a full solution at the last minute. The version history alone — visible in the LMS timestamps — was often enough to identify submissions where the entire project appeared fully-formed in a single commit.
Oral spot-checks for high-risk submissions
When Codequiry flagged an unusually high similarity report, we started pulling students for a 10-minute Zoom walkthrough of their own code. Three semesters of doing this, and we've heard more honest confessions in those ten minutes than in five years of honor-council hearings. The policy itself — announced on the syllabus — acted as a deterrent. Students who knew they might have to explain a lambda pipeline line-by-line thought twice about pasting from a friend.
This combination — personalization, process evidence, and lightweight oral verification — didn't require extra TAs. The grading scripts handled most of the overhead, and the detection tool narrowed the pool of suspicious cases to a manageable handful.
Where detection tools still earn their keep
Even after redesign, students found workarounds. Some paid someone to complete the personalized assignment (contract cheating). Others copied the logic from GitHub but rewrote variable names. A few used ChatGPT to generate a solution and then retrofitted the personalized test input — a technique that falls right in the gap between traditional similarity checkers and simple AI-text detectors.
This is where a platform that does both peer and web-source comparison, plus AI detection, becomes the backstop. Codequiry’s web-matching caught a student who had directly adapted a GeeksforGeeks article; the token-based similarity with the rest of the class was low because nobody else used that source. The AI code detector surfaced a handful of submissions where the code structure, comment density, and uniform spacing patterns matched known LLM signatures even though the variable names had been individualized.
“The redesign prevented 90% of casual copying. The remaining 10% were sophisticated enough that we needed multi-source detection — peer, web, and AI — to see the full picture.” — Senior lecturer, computer science department
We learned not to choose between design and detection, but to let each do what it does best. Good assignments make cheating expensive; good detection makes it visible.
What broke and what we fixed
Personalization at scale wasn't trivial. In the first run, we underestimated how many students would share their personalized input file with friends, who'd then write a solution tailored to that input and share it back. We closed that by having the autograder verify that the submitted output matched their own seed at runtime, but also by running Codequiry’s peer comparison on the submissions, which caught the resulting clusters.
Another failure mode: students who used AI rewriters to alter variable names and restructure code but kept the core algorithm identical. The token-stream analysis in Codequiry's similarity engine still flagged those because the semantic fingerprint survived the rewriting. That gave us confidence that we weren't just measuring syntactic similarity.
For teams using a continuous integration pipeline or managing internal codebases, the same ideas translate. Contractors delivering personalized micro-projects with unique test harnesses make it harder to submit identical work across clients. An API-based source code plagiarism checker that integrates into a build pipeline can verify originality without a manual review step.
Frequently Asked Questions
Can assignment design really stop all plagiarism?
No single intervention stops all cheating. Design makes casual copying impractical, forces contract cheaters to invest more effort, and surfaces anomalies that detection tools can then isolate. The combination is what brings numbers down.
How do you personalize assignments for a class of 300 without going insane?
Automate with a script that generates test inputs from a student ID hash, and use an autograder that checks correctness against that unique input. The grading pipeline stays the same; only the expected outputs differ.
What about AI-generated code that's been modified to match a personalized prompt?
Students will prompt an LLM with their unique test string and submit the resulting code. That code often bears statistical markers — unnaturally uniform spacing, low logical nesting depth, a specific comment-to-code ratio — that AI detectors flag even when the output has been tweaked. Running an AI code detector alongside similarity checks gives you visibility into both axes.
Does Codequiry check against submissions from previous semesters?
Yes, and that’s critical. Our archive of past semesters' submissions repeatedly caught students who reused a solution from a friend who took the course the previous year. Without that cross-semester comparison, those cases would have looked like fresh, independent work.
Explore how Codequiry’s code plagiarism checker can surface the copying that even the best assignment designs can't prevent.