How High School AP Computer Science Principles Teachers Can Verify Authentic Authorship in Create Performance Task Written Responses

Figure 1: Checkmark's AP CSP Create Performance Task Dashboard cross-referencing code against written responses, keystroke telemetry, and College Board Rows 1–6 autograding. AP CSP Create PT Ready

1. The Disciplinary Architecture of the AP CSP Create Performance Task

In secondary computer science education, the College Board’s Advanced Placement Computer Science Principles (AP CSP) curriculum serves as a foundational gateway into computational thinking, algorithmic problem solving, and software engineering. Unlike traditional programming assessments that evaluate solely whether source code compiles, satisfies unit tests, or matches a reference implementation, the AP CSP Create Performance Task (Create PT) places equal, if not greater, weight on the student’s capacity to articulate, document, and defend their computational artifacts in formal technical writing.

For 9th through 12th-grade computer science teachers managing 120 to 160 students across five or six class periods, evaluating the Create PT presents a unique pedagogical challenge. Students spend at least 12 in-class hours designing games, simulation engines, quiz apps, or utility tools. Yet, the final AP score hinges decisively on the clarity, accuracy, and depth of the Written Responses.

The Anatomy of the Four Written Response Prompts

To earn full credit across the College Board’s analytical scoring criteria, students must respond to four highly structured prompts, each targeting a specific computational concept and rubric row:

Language Neutrality Across Text-Based and Block-Based Environments

A defining strength of the AP CSP course is its language neutrality. High school classrooms across the United States implement the curriculum using diverse developmental platforms:

• Block-Based Environments: Code.org App Lab, MIT App Inventor, Scratch (MIT Media Lab), Snap! (UC Berkeley), and Microsoft MakeCode.
• Text-Based Environments: Python (via Replit, IDLE, or VS Code), JavaScript (via Code.org App Lab or HTML5 Canvas), Swift, and Java.

Regardless of the platform, the written response demands are identical. A student building a block-based turtle-graphics game in Snap! must explain data abstraction with the exact same conceptual precision as a student developing a text-based inventory management system in Python.

# Authentic Student Python Example: Algorithmic Procedure with Iteration & Selection
def filter_high_scorers(score_list, minimum_threshold):
    """Traverses score_list, filters scores above threshold, returns count."""
    qualifying_count = 0
    # Iteration: Traverses each element in the list
    for score in score_list:
        # Selection: Evaluates score against parameter threshold
        if score >= minimum_threshold:
            qualifying_count += 1
            print(f"Qualifying score found: {score}")
        else:
            print(f"Score below cutoff: {score}")
    return qualifying_count

# Procedure Call 1: minimum_threshold = 80 -> Executes 'if' branch 3 times
result_a = filter_high_scorers([95, 82, 74, 88, 60], 80)

# Procedure Call 2: minimum_threshold = 100 -> Executes 'else' branch for all elements
result_b = filter_high_scorers([95, 82, 74, 88, 60], 100)

The Acute Classroom Dilemma: Working Code, Outsourced Explanations

The primary integrity vulnerability in high school AP CSP classrooms is not simply whole-program plagiarism. Rather, it is a nuanced, hybrid form of academic fraud: code-commentary dissociation.

A student successfully builds a working arcade game in Code.org App Lab or a text-based inventory tool in Python. However, when faced with drafting the dense, rubric-governed written responses—intimidated by College Board criteria or pressed for time—the student copies their 80 lines of working code into ChatGPT or Claude and prompts:

“Here is my JavaScript code for an AP CSP project. Write my Written Responses for WR 1, WR 2, WR 3, and WR 4 so I get all 6 rubric points on the College Board rubric.”

The Large Language Model instantly produces a response that sounds authoritative, sophisticated, and grammatically flawless. However, upon close inspection by an experienced computer science educator, these AI-generated commentaries exhibit three glaring structural defects:

2. College Board Policies, Rubric Rows, and Why Generic AI Detectors Fail CS Teachers

To address the surge of generative AI, the College Board updated its official AP Computer Science Principles policy regarding Artificial Intelligence and plagiarism. Understanding the exact boundaries of this policy is essential for high school educators, department chairs, and AP coordinators.

The AP CSP Scoring Rubric Matrix (Rows 1–6)

Every high school AP CSP teacher must evaluate classroom drafts against the College Board’s six analytic rubric criteria:

Why Generic Commercial AI Detectors Fail High School CS Teachers

Faced with grading stacks of 150 Create PT submissions, many high school teachers and districts have turned to generic commercial AI detectors (such as Turnitin AI detector, GPTZero, or CopyLeaks). In secondary computer science classrooms, these tools fail catastrophically for three technical reasons:

When a generic detector assigns a “70% AI Probability” to an honest student’s explanation of a Python for loop, the teacher is left in an impossible position: either accuse the student based on an opaque, unexplainable probability score, or ignore the alert entirely. To achieve defensible academic integrity, computer science educators need transparent, process-based evidentiary telemetry.

3. The High School Computer Science Evidentiary Matrix

To evaluate student authorship objectively without relying on arbitrary black-box scores, high school computer science departments require a comprehensive evidentiary framework. The matrix below compares the four primary methodologies available to secondary educators:

While manual 1-on-1 code walkthroughs remain the gold standard for pedagogical depth, conducting 150 individual 15-minute conferences requires over 37 hours of educator time—an impossibility for high school teachers with standard 50-minute planning periods. Checkmark Plagiarism provides the objective telemetry necessary to deliver the evidentiary precision of an oral debrief at the speed and scale required for public and private secondary schools.

4. Step-by-Step Computer Science Teacher Audit Protocol

When evaluating AP CSP Create Performance Task written responses, high school computer science educators should follow a structured, four-step audit protocol to ensure defensible evaluation, protect honest students, and identify outsourced explanations.

Step 1: Code-to-Commentary Concordance Audit

The first line of defense is comparing the student’s submitted code PDF directly against their written responses for WR 1 through WR 4. Educators should verify four critical concordance touchpoints:

1. Identifier Exactness: Do the variable and list names cited in WR 2 and WR 3 match the exact capitalization, spelling, and scope of the source code? (e.g., An LLM might write score_list when the student’s code actually names the array userScoreArray).
2. Parameter Binding in WR 4: Does the procedure identified in WR 4 take an explicit formal parameter, or is it a zero-argument function that merely manipulates global variables?
3. List Mutation and Traversal: Does the iteration code in WR 3 actually traverse the list identified in WR 2?
4. Return Value Consistency: If WR 4 claims the procedure returns a Boolean or transformed integer, does the source code contain an active return statement, or does it merely update a user interface element?

var highScores = [120, 95, 80, 65, 50]; // List of integer scores

function checkEligibility(playerScore) {
    // Procedure with explicit parameter 'playerScore'
    var isEligible = false;
    for (var i = 0; i < highScores.length; i++) {
        if (playerScore > highScores[i]) {
            isEligible = true;
        }
    }
    return isEligible;
}

Step 2: Algorithmic Sanity and Complexity Validation

In WR 2, College Board Row 3 requires students to explain why their program could not easily be written without their list abstraction. This prompt represents the most common failure point for both struggling students and generic AI tools.

Teachers should audit whether the response provides a concrete counter-factual scenario: describing exactly how many scalar variables, repetitive conditional blocks, or broken features would occur without the list.

Step 3: Writing Process Telemetry and Keystroke Dynamics (Essay Playback™)

When an educator observes a written response with suspicious vocabulary or boilerplate complexity claims, Checkmark’s Essay Playback™ provides conclusive, timestamped writing process evidence.

Step 4: The Restorative “Live Code Tracing” Conference Protocol

When writing telemetry indicates that a student outsourced their Create PT written responses, educators should avoid adversarial confrontations. In alignment with Checkmark’s philosophy—“Stop guessing, start trusting”—the goal is to transform the incident into a high-impact learning conference.

This restorative protocol protects student dignity, reinforces genuine computational concepts, and ensures that the final materials submitted to the College Board AP Digital Portfolio represent the student’s authentic intellectual work.

5. Checkmark Plagiarism: Purpose-Built Integrity for Secondary Computer Science

Checkmark Plagiarism is engineered specifically to meet the evidentiary, pedagogical, and workflow requirements of 9th–12th grade computer science educators, department chairs, and district technology leaders.

6. Frequently Asked Questions (FAQ)