The email arrived in Professor Aris Thorne's inbox at 2:17 AM on a Tuesday. The subject line was stark: "URGENT: Possible Honor Code Violation - CS310." The body, from a distressed teaching assistant named Leo, contained a screenshot of a Discord server chat. In it, a student shared a Google Drive link with the message, "Finalized version of the GraphTraversal module. Just rename variables and you're golden."
Thorne taught Data Structures and Algorithms at Carlton University, a program consistently ranked in the top twenty nationwide. The assignment in question was a classic: implement Dijkstra's algorithm in Python to find the shortest path through a network, with specific requirements for heap optimization and a particular output format. It was worth 15% of the final grade.
"I ran it through MOSS," Leo's email continued, referring to the Stanford-developed plagiarism detection system Carlton had used for a decade. "The pairwise matches came back under 10% similarity for most submissions. But this... this is a blueprint. They're not copying code. They're copying architecture."
The Illusion of Originality
Thorne downloaded the 87 student submissions and the shared "blueprint" file. At first glance, Leo was right. The MOSS report showed the typical low-level matches—import statements, common variable names like `visited` or `distances`, and the basic skeleton of a priority queue. Nothing flagged for manual review under the department's 25% similarity threshold.
But when Thorne opened five random submissions side-by-side, a different pattern emerged. The code was structurally identical. Not line-for-line, but in its fundamental organization.
"We were measuring the wrong thing," Thorne told me later. "We were looking for stolen sentences when the entire essay outline had been photocopied and just rewritten in different handwriting."
Every submission followed this exact modular breakdown:
# Module 1: A dedicated Node class with identical attributes
class GraphNode:
def __init__(self, id):
self.id = id
self.adjacent = {} # dict of neighbor: weight
# Module 2: A Graph class with an `add_edge` method signature
class Graph:
def __init__(self):
self.nodes = {}
# Module 3: The Dijkstra function with a specific helper pattern
def dijkstra(graph, start):
distances = {node: float('inf') for node in graph.nodes}
distances[start] = 0
pq = PriorityQueue()
pq.put((0, start))
# A specific, non-standard visited-checking pattern
visited_check = set()
while not pq.empty():
current_dist, current_node = pq.get()
if current_node in visited_check:
continue
visited_check.add(current_node)
# The traversal loop with a specific iterator name
for neighbor, weight in graph.nodes[current_node].adjacent.items():
distance = current_dist + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
pq.put((distance, neighbor))
return distances
# Module 4: A custom PriorityQueue implementation (when heapq was allowed)
class PriorityQueue:
def __init__(self):
self.heap = []
def put(self, item):
heapq.heappush(self.heap, item)
def get(self):
return heapq.heappop(self.heap)
def empty(self):
return len(self.heap) == 0
Individually, each piece was logical. Together, they formed a unique fingerprint. The assignment specification required Dijkstra's algorithm. It did not mandate a separate `GraphNode` class, a specific `visited_check` pattern inside the main loop, or a custom `PriorityQueue` wrapper when Python's `heapq` module was sufficient. The spec was three pages; the shared solution's architecture was a creative, over-engineered interpretation.
"That was the tell," said Leo, the TA who first spotted it. "No student naturally builds a custom PriorityQueue class for a one-off assignment unless they're following a template. It's academic cargo-culting. They replicate the structure without understanding why it exists."
The Scale of the Problem
Thorne and his TAs spent the next 72 hours conducting a manual audit, moving beyond line similarity to architectural analysis. They identified seven distinct "solution templates" circulating on Discord, GroupMe, and through a fraternity's academic server. Each template had minor variations—different class names, slightly refactored loops—but identical control flow and data structure choices.
Out of 87 submissions:
- 62 followed one of the seven identified templates (71%).
- 48 of those showed MOSS similarity scores below 15% to the original template source.
- 22 submissions were essentially template code with variable names changed via simple find-and-replace.
- Only 25 submissions appeared to be independently architected.
The honor code violation was massive, but the disciplinary process was designed for one-off cheating, not a systemic breakdown. "We couldn't fail 62 students," Thorne said. "The department would never allow it. The appeals would tie us up for years. And honestly, the failure was ours. We'd given them a boilerplate problem and were surprised they found a boilerplate solution."
Rebuilding the Assignment, Not Just Catching Cheaters
Instead of moving directly to punishment, Thorne took an unconventional approach. He cancelled the original assignment grade. In class, he displayed anonymized snippets of the template code alongside the original specification.
"You were asked to find the shortest path," he told the silent lecture hall. "Many of you submitted code that builds a custom kitchen, designs a new type of knife, and then uses it to butter toast. I'm not mad you used a template. I'm concerned you didn't ask why the template was built that way."
He announced a replacement assignment with a critical twist: personalization through constraints.
The new problem still involved shortest-path algorithms, but with these requirements:
- You must use a specific, provided starter class called `Network` that had a fixed, poorly-designed API. Students had to work around its inefficiencies.
- The algorithm had to handle two simultaneous constraints (shortest path under a total cost limit), forcing a modification to the core algorithm logic.
- A 3-5 line written justification was required for any external code used, explaining its integration point.
- All submissions would be scanned with a tool that compared Abstract Syntax Trees (ASTs), not just tokens, looking for structural cloning. Thorne's team used Codequiry's platform for this deeper analysis, moving beyond surface-level similarity.
"The goal wasn't to make cheating impossible," Thorne explained. "It was to make authentic problem-solving easier than copying. When the assignment itself requires you to make unique, justifiable design choices, a shared template becomes useless."
The Aftermath and the New Standard
The results were telling. The replacement assignment had a 92% original submission rate based on AST analysis. Performance was more varied—some students struggled with the novel constraints—but the work was authentic.
The Carlton CS department learned three hard lessons that semester:
1. Token-based detection is obsolete for modern cheating. Students aren't copying textbooks. They're sharing architectural patterns, solution strategies, and refactored code snippets from private repositories. Tools that only measure lexical similarity are blind to this.
2. The assignment design is your first line of defense. A generic problem invites a generic, shareable solution. "If your spec can be fully satisfied by a GitHub gist from 2017," said Leo, "you have written a bad spec."
3. Academic integrity is a culture, not a compliance check. The department shifted its focus. Instead of a single "thou shalt not cheat" lecture, they now integrate integrity modules into coursework: how to read and adapt Stack Overflow code ethically, how to cite algorithms, where the line is between collaboration and plagiarism in pair programming.
The scandal never made the news. No students were expelled. But in the faculty lounge, the change is palpable. Assignment specs now include unique seeds—student-specific data files or parameters that alter the problem space. Exams include questions that ask students to critique or modify provided code snippets, testing comprehension, not just regurgitation.
"We stopped trying to be police officers," Thorne concluded. "We started trying to be architects of learning environments where honesty is the most rational path. The detection tools are still there—we use them more than ever—but they're a backstop, not the main strategy. The real fix happened when we looked in the mirror and realized we were giving them cheat-worthy assignments."
The Discord server where it all started is still active. But last month, a student posted a question about the latest project. The first reply wasn't a Google Drive link. It was: "Have you tried talking to the TA? She helped me figure out my unique constraint issue in office hours."
That, perhaps, was the real victory.