How Can Computer Science Teachers Use Keystroke Replay and Revision History to Verify Student Code Authorship? | Checkmark Plagiarism

Checkmark Plagiarism provides STEM educators, department chairs, and academic deans with a comprehensive integrity suite that bridges the evidentiary gap: patent-pending Essay Playback™ code construction telemetry, passage-level AI logic analysis, in-cohort private repository matching, and quote-anchored AI rubric autograding integrated natively with Canvas LMS SpeedGrader and Agilix Buzz LMS.

Figure 1.0: Checkmark Code Construction Telemetry — Keystroke Replay, AST Comparison, Paste Payload Forensics, and Debugging Timeline. Patent-Pending Keystroke Telemetry

1. The Generative Code Crisis in Modern CS Education: Beyond Syntax Checking

For decades, introductory computer science education operated on a reliable assumption: if a student’s code compiles, executes without runtime exceptions, and passes an automated test suite of edge cases, the student has demonstrated computational thinking and algorithmic mastery.

The emergence of Large Language Models (LLMs) trained heavily on public code repositories (such as OpenAI’s GPT-4o, Anthropic’s Claude 3.5 Sonnet, GitHub Copilot, Cursor, and Replit AI) has obliterated that assumption. Today, a novice programmer with zero understanding of recursion, pointers, or dynamic programming can type a prompt into an LLM and receive a fully formatted, optimized, and commented implementation in under three seconds.

The Anatomy of Modern AI-Generated Student Submissions

Generative coding tools do not just write snippets; they generate end-to-end architectures. In high school AP Computer Science and college undergraduate courses, instructors routinely encounter three distinct manifestations of AI-generated code:

2. The Cognitive Anatomy of Programming: Authentic Coding vs. Generative Ingestion

Programming is not a linear act of typing characters from top to bottom. Cognitive science and educational psychology demonstrate that learning to program is a non-linear, highly iterative cycle of hypothesis generation, syntax formulation, mental execution, failure, and refactoring.

The Authentic Human Coding Pattern

When human learners build software, their keystroke telemetry reveals unmistakable markers of active mental processing:

• Incremental Scaffolding & Syntax Stumbling: Beginners frequently misplace curly braces, forget closing parentheses, misspell variable names, or miss semicolons. They type, receive compiler feedback, pause to read the error message, and navigate back to make targeted edits.
• Cognitive Pauses at Algorithmic Cruxes: In human coding telemetry, long pauses (15–90 seconds) occur exactly where algorithmic complexity spikes: before writing loop boundary conditions, before defining recursive base cases, or when structuring nested conditional logic.
• Exploratory “Print-and-Trace” Artifacts: Authentic learners frequently insert temporary output statements (print(f"DEBUG: x={x}"), System.out.println("inside while loop"), or console.log(data)) to inspect runtime state, running the script multiple times to observe behavior before continuing.
• Iterative Refactoring & Deletion Bursts: Beginners often write a brute-force approach, realize an edge case fails, delete entire blocks of code, and restructure their logic. This non-linear evolution is the signature of genuine problem-solving.

The Generative Outsourcing Pattern

Conversely, submissions derived from generative AI exhibit telemetry that violates natural human cognition:

• Instantaneous Clipboard Ingestion: An entire 80-line class or complex algorithmic function appears in the IDE within a single 200-millisecond window (a paste payload containing thousands of characters).
• Superficial “Camouflage” Editing: After pasting an LLM payload, the student spends 2–3 minutes doing cosmetic edits: changing variable names (e.g., temp to myVal), deleting generated docstrings, or adding random whitespace to make the code appear personal.
• Mechanical Transcription (The Second-Screen Trap): When students know that copy-pasting is monitored, they place a smartphone, tablet, or secondary monitor next to their keyboard and manually retype the AI-generated code. Keystroke telemetry captures this as a flat, mechanical cadence (50–70 words per minute) with near-zero backspaces, no pauses at algorithmic decision points, and no intermediate compilation or runtime testing. The student is typing code as if it were a typing speed test, not an intellectual challenge.

3. The Pedagogical Dilemma: Why Static Tools (MOSS, JPlag, Generic AI Checkers) Fail CS Instructors

Computer science educators have utilized automated integrity tools for decades, most notably MOSS (Measure of Software Similarity) developed at Stanford University, and JPlag. While these tools were revolutionary for detecting student-to-student copying, they are fundamentally unsuited for the era of generative AI.

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

def find_element(data, key):
    left = 0
    right = len(data) - 1
    while left <= right:
        middle = left + (right - left) // 2
        if data[middle] < key:
            left = middle + 1
        elif data[middle] > key:
            right = middle - 1
        else:
            return middle
    return -1

1. The Architectural Failure of MOSS and JPlag Against LLMs

MOSS and JPlag operate via Abstract Syntax Tree (AST) tokenization and the Winnowing algorithm. They replace variable names with generic tokens, construct k-gram structural hashes, and match identical subtrees across submissions in a cohort:

• LLM Structural Entropy: Generative models do not copy verbatim from a fixed peer. Every prompt produces slight variations in control flow (e.g., while loops vs. recursion, differing condition order, alternative helper methods, or varied algorithmic tricks). MOSS computes low similarity scores across AI-generated files because the specific AST token sequences diverge.
• No Historical Web Index: MOSS only compares student files against other files submitted in the same batch (or a static instructor archive). It cannot detect when a student prompts an external LLM to write code from scratch.

2. The Catastrophic False Positive Problem on Canonical Algorithms

When educators turn to generic, whole-file AI text detectors, the results in computer science are disastrous:

• Canonical Algorithms Have Zero Structural Entropy: In CS1 and AP CS A, assignments focus on foundational algorithms: Linear Search, Binary Search, Selection Sort, Merge Sort, Fibonacci numbers, or Palindrome checkers. There are only so many mathematically logical ways to write an 8-line Binary Search in Java or C++.
• Generic Detectors Penalize Clean Code: Because canonical algorithms are mathematically deterministic, their perplexity is naturally low. Generic AI detectors look at a pristine, correctly written human student implementation and assign it a 95%–100% AI probability score.
• Devastating Impact on Honest Novices: When a dedicated student spends three hours in the tutoring center perfecting their nested loops, and the teacher confronts them based on an opaque 98% AI detector score, the student’s trust is shattered. In STEM, false accusations disproportionately alienate neurodivergent learners and students from non-traditional computing backgrounds.

4. Checkmark Plagiarism’s Multi-Dimensional Architecture for Computer Science

Checkmark Plagiarism provides a transparent, defensible, and pedagogically supportive platform engineered to help educators answer the question: “Did this student actively build this program?”

1. Patent-Pending Essay Playback™ for Programming Workflows

Checkmark’s core innovation is the reconstruction of the entire writing and coding session. Working within native web IDEs, Google Docs, Microsoft Word, or embedded LMS essay/code submission boxes (Canvas LMS, Buzz LMS, Moodle), Checkmark records every discrete event: character insertions, backspaces, arrow key navigations, selection deletions, and focus switches.

Educators can scrub through the timeline like a video at 1x, 2x, 4x, or 8x speed. An instructor can watch a student type a function header, pause for 30 seconds to think, write an incorrect loop boundary, delete it, insert a debug statement, test the condition, and finally arrive at the working solution. This video-grade playback serves as indisputable proof of authentic authorship.

2. External Paste Retention (Even After Heavy Refactoring)

A common evasion tactic among students is pasting an entire function from ChatGPT, then spending ten minutes manually renaming variables (x to counter, temp to currentVal), altering indentation, and adding their own comments.

Checkmark completely neutralizes this tactic. When text is pasted from an external window (a web browser, ChatGPT tab, or notes app), Checkmark:

1. Immediately logs the paste event with a high-visibility badge in the playback timeline.
2. Archives the 100% complete, original clipboard payload in the submission evidence dossier.
3. Provides a “View Original Paste Payload” modal that displays the exact raw text that entered the clipboard—allowing the instructor to see the original ChatGPT output, complete with AI-generated comments and variable names, even if the student deleted or modified every single character afterward.

3. Granular Passage-Level AI Analysis with Short-Code Guardrails

Unlike generic tools that output an unhelpful “78% AI” score for the whole document, Checkmark evaluates code and comments at the passage level. Specific blocks are highlighted with calibrated confidence sliders that display whether the linguistic and structural patterns match typical human novice writing or characteristic LLM generation.

Crucially, Checkmark enforces Honest Short-Text Guardrails: any code block or explanatory response under ~150 words displays N/A rather than generating unreliable probabilistic guesses. This prevents false positive flags on short helper methods or concise loop headers.

4. Zero-Retention Security & FERPA / COPPA Compliance

In compliance with school district privacy mandates and collegiate institutional policies:

• Zero Model Training: Student code submissions are never used to train, fine-tune, or calibrate commercial or open-source AI models.
• Enterprise Encryption: All telemetry data and code archives are encrypted in transit (TLS 1.3) and at rest (AES-256).
• Strict LMS Integration: Works seamlessly through LTI 1.3 standards across Canvas LMS, Buzz LMS, Google Classroom, and Schoology.

5. The Step-by-Step CS Teacher Code Audit Protocol

When a computer science instructor, department chair, or academic integrity dean receives a submitted program, they should never rely on hunches or single-percentage scores. Instead, they should follow this standardized four-phase audit protocol.

Phase 1: Macro-Metric Triage (60-Second Scan)

Open the Checkmark Integrity Report for the assignment submission. Examine three primary telemetry indicators:

1. Total Active Composition Time: Did the student spend 45 minutes drafting an intricate data structure, or was the file completed in 90 seconds?
2. Paste Volume Percentage: What proportion of the final code was typed via keyboard vs. inserted via clipboard paste? (Legitimate starter code provided by the teacher will be accounted for; unannounced 80-line pastes will be highlighted in orange/red).
3. Event Density Curve: A healthy session displays a wave-like distribution of typing bursts followed by reading/thinking troughs. A flat line followed by a vertical spike indicates external generation.

Phase 2: Playback Timeline Scrubbing (1x–8x Replay)

Launch the Essay Playback™ viewer. Scrub through the session at 4x or 8x speed:

• The Algorithmic Pivot: Does the student start by writing a basic loop, test it, realize it fails an edge case, and modify their approach?
• Syntax Error Recovery: Does the student struggle with language syntax (e.g., typing length instead of length(), forgetting a semicolon, or mixing up . and -> in C++) and fix it after reviewing compiler output?
• Comment Synchronization: Did the student write comments while thinking through the logic, or did 50 lines of complex code appear instantly with polished Javadoc/Doxygen comments already attached?

Phase 3: External Clipboard Payload & Transcription Inspection

If external paste events are detected:

• Click on the paste badge in the timeline to open the Clipboard Payload Inspector.
• Compare the pasted content against the assignment prompt. Did the student paste an entire completed method from an LLM? Or did they paste an allowed API documentation URL or a snippet from lecture slides?
• If the code was typed manually but shows suspicious fluency, check the Keystroke Velocity Graph. If the student typed 120 lines of flawless, deeply nested code at a continuous 70 WPM without ever running the program or making a single typographical error, this indicates mechanical transcription (retyping from a phone or second screen).

Phase 4: The Supportive Viva Voce Code Defense

If the telemetry suggests external generation, the teacher does not issue an immediate punitive zero. Instead, the educator schedules a short, supportive conference. The playback timeline is displayed on screen as a shared, objective artifact. The teacher asks the student to explain specific moments in the replay, fostering an honest, educational dialogue.

6. Realistic Classroom Case Scenarios in Secondary & Higher Education CS

To illustrate how process telemetry operates in practice, examine three realistic scenarios from secondary and collegiate computer science classrooms.

public boolean solveMaze(int row, int col) {
    if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length) return false;
    if (grid[row][col] == GOAL) return true;
    if (grid[row][col] != OPEN) return false;
    
    grid[row][col] = PATH;
    for (int[] dir : DIRECTIONS) {
        if (solveMaze(row + dir[0], col + dir[1])) return true;
    }
    grid[row][col] = VISITED;
    return false;
}

def binary_search_leftmost(arr, target):
    left = 0
    right = len(arr) - 1
    result = -1
    
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid] == target:
            result = mid
            right = mid - 1  # Continue searching left
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
            
    return result

async function fetchWeatherData(cities) {
    try {
        const promises = cities.map(city => 
            fetch('https://api.weather.com/v1/' + city).then(res => {
                if (!res.ok) throw new Error('HTTP error! status: ' + res.status);
                return res.json();
            })
        );
        const results = await Promise.allSettled(promises);
        return results.filter(r => r.status === 'fulfilled').map(r => r.value);
    } catch (err) {
        console.error("Critical telemetry fetch failure:", err);
        return [];
    }
}

7. The Restorative “Viva Voce” Code Conference Framework

The core philosophy of Checkmark is “Stop guessing, start trusting.” Academic integrity tools should never be used as punitive weapons; they should serve as transparent mirrors that facilitate meaningful educational conversations.

When telemetry indicates unauthorized AI generation or uncredited code copying, instructors should implement the Five-Step Restorative Code Defense (Viva Voce) Protocol.

Five Diagnostic Questions for Code Replay Conferences

During the playback review, instructors can use these five non-adversarial, highly diagnostic questions:

1. “Walk me through your mental model right here.” (Pausing the playback at an algorithmic crux or immediately following a paste event).
2. “If I pass the input array [4, 0, -2] into this method, what will the variable temp equal after the first loop iteration?” (Tests code-tracing comprehension).
3. “I notice this helper method was pasted in from an external window. Where did you find this pattern, and how does it fit into your overall program design?” (Invites honest disclosure of external sources).
4. “Why did you choose to use a HashMap here instead of an ArrayList or primitive array?” (Evaluates intentionality vs. arbitrary AI generation).
5. “Let’s make a small live modification right now: how would we adjust line 24 if the array could contain negative numbers?” (Instant validation of true mastery).

8. Strategic Implementation Guide for CS Department Chairs & STEM Directors

For school district technology directors, high school STEM coordinators, and university CS department chairs, scaling academic integrity requires systemic policy alignment, robust infrastructure, and educator professional development.

Seamless LMS & IDE Integration Workflows

Checkmark integrates natively into existing educational technology ecosystems via LTI 1.3:

• Canvas LMS & SpeedGrader: Checkmark embed cards appear directly inside SpeedGrader. Teachers can launch the Essay Playback™ video viewer without leaving Canvas. AI-assisted rubric evaluations sync directly back into the Canvas Gradebook with a single click.
• Buzz LMS & Google Classroom: Direct grade and rubric passback eliminates double-entry grading for STEM faculty managing heavy course loads.
• Browser & Web-IDE Extensions: Integrates directly with browser-based coding sandboxes, LMS essay boxes, and web IDEs to capture telemetry with zero friction.

Departmental Standardization & FERPA Data Sovereignty

When evaluating academic integrity vendors, IT directors and department chairs must demand three non-negotiable guarantees:

1. Zero LLM Training Rights: Ensure the vendor contract explicitly bars the use of student code submissions for AI model training or commercial dataset refinement.
2. Deterministic Process Receipts: Eliminate dependency on opaque black-box AI scores that cannot be defended in parent conferences or academic appeals.
3. FERPA & COPPA Compliance: Ensure all student data, keystroke records, and source files are encrypted with enterprise-grade cloud security.

9. Frequently Asked Questions (FAQs) for CS Educators

Conclusion: Fostering Authentic Problem-Solvers in the Age of AI

The goal of computer science education has never been to produce human code compilers. It is to cultivate creative, resilient thinkers capable of decomposing complex problems, persevering through cognitive struggle, and architecting elegant algorithmic solutions.

Generative AI is a permanent fixture of the modern technological landscape. Attempting to police it with opaque, probabilistic black-box detectors is a losing battle that damages classroom culture and punishes honest students.

By embracing Checkmark Plagiarism’s patent-pending Essay Playback™ and Writing Process Telemetry, computer science educators gain the objective, transparent receipts needed to protect authentic learning. By shifting the pedagogical focus from the static finished file to the dynamic journey of creation, teachers can stop guessing, start trusting, and inspire the next generation of authentic software engineers.