AP Computer Science Principles Create Performance TaskPPR Scoring Guide and College Board Resources (2022 to 2025)

What does the AP Computer Science Principles Create Performance Task test?

The Create PT tests whether you can design and implement a program that solves a real problem, then explain in writing how you used data abstraction and algorithmic thinking to do it.

Unlike the multiple choice section that asks you to read and reason about provided code, the Create Performance Task requires you to produce original work over weeks. You build a program using any approved language, then submit the Personalized Project Reference, two written responses that explain specific elements of your program. The first response covers data abstraction: you show a code segment that uses a list to manage complexity, explain what the list stores, and explain why storing that data in a list is more manageable than an alternative approach. The second response covers algorithm implementation with procedural abstraction: you show a procedure you developed that includes sequencing, selection, and iteration, then describe what the procedure does and how its algorithm works. College Board readers score your PPR against a 6-point rubric, with each of the six rows worth exactly 1 point. Per the AP Computer Science Principles Course and Exam Description published by College Board, the Create PT accounts for 30 percent of the total AP score.

What are the two Create PT written responses?

Response 1 demonstrates data abstraction. Response 2 demonstrates algorithm implementation with procedural abstraction. Each is scored against three dedicated rubric rows.

The Personalized Project Reference is not a traditional written essay. It is a structured submission with two responses, each tied to specific code segments from your program. You submit screenshots or copies of your code alongside the written explanations. College Board readers evaluate each response against precise rubric criteria, awarding 0 or 1 point per row. Both responses draw from the same program, so a program with a well developed algorithm and meaningful use of a list sets up both responses to succeed.

How is the AP CSP Create Performance Task scored?

Six College Board readers each independently apply one rubric row to your PPR. Each row is worth exactly 1 point with no partial credit, for a maximum score of 6.

The Create PT is scored centrally by College Board readers, not by your teacher. Your submitted PPR, including your written responses and code segments, is read by trained readers who apply the scoring rubric. The rubric has six rows, and each row is either earned (1 point) or not earned (0 points). There is no partial credit within a row and no penalty for attempting a response. The 6 raw points from the Create PT are weighted to equal 30 percent of the overall AP score. Per College Board's scoring guidelines published annually, the rubric rows are: Row 1 (program purpose and function), Row 2 (data abstraction), Row 3 (managing complexity), Row 4 (procedural abstraction), Row 5 (algorithm implementation), and Row 6 (testing). Rows 2 and 3 together address the data abstraction response. Rows 4 and 5 together address the algorithm implementation response. Your score is not curved or adjusted based on what other students submitted. The rubric criteria are fixed and the same for every student in every year.

Worked example: how a Create PT PPR response earns or loses each rubric row

Row 3 (managing complexity) and Row 5 (algorithm implementation) are the two rows most frequently not earned per College Board reader observations. Both require specific explanatory moves that students most often miss.

The example below traces the distinction between a response that earns each rubric row and one that does not, using a hypothetical program that manages a playlist. The program stores song titles in a list and uses a procedure that filters songs by genre. This type of program is representative of the programs students submit: it involves a list with a meaningful use, a procedure with parameters, and at least one conditional and one loop. The rubric analysis is grounded in the scoring criteria College Board has published in the 2023 and 2024 scoring guidelines, which show consistent row-by-row commentary on what earns and loses each point.

1. Row 3: Explain how the list manages complexity in the program

   Rubric: 1 point earned when the response explains why using a list makes the program more manageable than an alternative, connecting the explanation to the specific role the list plays in the student's program. The explanation must go beyond stating that a list can store multiple values.

   Earns the point: The program stores song titles in a list called playlist. Without this list, the program would need a separate variable for each song, and the filtering procedure could not loop over the songs to check each title against the genre. Using a list allows the procedure to process all songs with a single loop regardless of how many songs are in the playlist, making the program manageable at any scale.

   Loses the point: The list playlist stores multiple song titles. Without a list, it would be difficult to manage the data. This response restates that a list stores multiple values without explaining how the list specifically reduces the complexity of this program. It does not address why a separate variable approach would be harder or what the list enables that individual variables would not.

2. Row 5: Describe how the algorithm in the procedure works, including sequencing, selection, and iteration

   Rubric: 1 point earned when the response identifies sequencing, selection, and iteration present in the procedure and explains the role each plays in how the algorithm achieves its result. The procedure must contain student written logic, not just a call to a built in function.

   Earns the point: The procedure filterByGenre takes the playlist list and a genre string as parameters. It first creates an empty list to store matches (sequencing). It then loops over each song in the playlist (iteration). Inside the loop, it checks whether the song's genre attribute equals the target genre (selection). If the condition is true, the song is added to the results list. After the loop completes, the procedure returns the results list. Each step is necessary: the loop ensures every song is checked, the conditional ensures only matching songs are added, and the return sends the filtered results back to the calling code.

   Loses the point: The filterByGenre procedure goes through each song and adds it to a list if it matches. It uses a loop and an if statement. This response identifies that a loop and conditional are present but does not describe the sequencing of steps, does not explain what each step accomplishes, and does not explain how the algorithm produces its result. Identifying the presence of the three components without explaining how they work together does not earn Row 5.

3. Row 6: Describe two test cases with different input values

   Rubric: 1 point earned when the two test cases use different input values (not the same value or same category of value), both state expected and actual results, and the results are consistent with what the code would produce.

   Earns the point: Test case 1: Input is an empty playlist list and genre string jazz. Expected result is an empty list returned. Actual result is an empty list. Test case 2: Input is a playlist containing four songs, two tagged jazz and two tagged pop, with genre string jazz. Expected result is a list containing the two jazz songs. Actual result matches the expected result. These two cases test different boundary conditions (empty input vs. populated input) and use different input values.

   Loses the point: Test case 1: Input genre is jazz, playlist has songs. The procedure returns jazz songs. Test case 2: Input genre is pop, playlist has songs. The procedure returns pop songs. Although these cases use different genre strings, they do not describe the full input (what songs are in the playlist), do not state expected output precisely, and do not confirm actual results. They describe the same category of test rather than genuinely different conditions.

Across all six rubric rows, the pattern is the same: the scoring rubric rewards specificity about your program. Generic statements about what lists do or what loops do in general lose points; specific statements about what your list does and how your algorithm works in your program earn them. The students who earn 5 or 6 points on the Create PT are not writing more impressive programs than students who earn 3 or 4 points. They are writing more precise, program specific explanations in their PPR responses. Practicing with the official scoring guidelines and reading the sample submissions at each score level is the most efficient preparation available.

Common AP Computer Science Principles Create Performance Task mistakes

1. 01

   Selecting a procedure that only calls built in functions, earning zero points on Row 5

   Row 5 requires a student developed procedure that contains the student's own algorithm logic, including sequencing, selection, and iteration. Students who submit a procedure whose body consists entirely of calls to built in language functions or library methods (for example, a procedure that calls sort() or filter() from a standard library) have not demonstrated that they developed the algorithm. College Board readers cannot award Row 5 to a procedure that delegates all logic to built in operations, because there is no student written algorithm to evaluate. Per College Board reader observations from multiple administrations, this is one of the most consistent sources of Row 5 failures. The fix is to ensure the selected procedure contains a student written loop and a student written conditional, not delegated equivalents.

   AP Computer Science Principles scoring guidelines and College Board reader commentary 2022 to 2024, Row 5 criteria

2. 02

   Failing to show both the segment with the list and the segment without the list for Row 2

   Row 2 requires two distinct code segments: one where the list is created or modified, and a separate one where the list is used in a way that does not include creation or modification. Students frequently submit only one code segment showing general use of the list, or two segments where both show the same type of use. The rubric is explicit: the two segments must be distinct, with one showing list creation or population and the other showing the list being accessed or processed in a separate context. Per the scoring guidelines published for 2023 and 2024, responses that show only one code segment or two segments that both show list creation do not earn Row 2 regardless of how well the written explanation explains the list's role.

   AP Computer Science Principles scoring guidelines 2023 and 2024, Row 2 criteria

3. 03

   Explaining managing complexity in generic terms rather than program specific terms, losing Row 3

   Row 3 is the row most commonly not earned in the data abstraction section. The rubric requires the response to explain how the specific list in the student's program manages the specific complexity of that program, not how lists manage complexity in general. Responses that write only that a list can store multiple values without extra variables, or that without a list the program would be harder to manage, describe what lists do in general rather than what this list does in this program. College Board reader observations consistently flag this as the gap between Row 2 earners and students who earn both Row 2 and Row 3. The explanation must identify the concrete alternative (what the program would look like without the list) and explain why that alternative would be more complex given the program's specific operations.

   AP Computer Science Principles scoring guidelines and College Board reader commentary 2022 to 2024, Row 3 criteria

4. 04

   Missing one of the three algorithm components (sequencing, selection, or iteration) in the Row 5 explanation

   Row 5 requires the response to describe a procedure that includes sequencing, selection, and iteration, and to explain how each contributes to the algorithm. Students who describe only two of the three components, or whose procedure code does not contain all three (for example, a procedure with a loop but no conditional), cannot earn Row 5. This is both a code selection error and an explanation error: students must first choose or develop a procedure that genuinely includes all three components, then explicitly identify all three in their explanation. Per College Board reader observations, the most common omission is failing to identify or explain sequencing, which students often treat as implicit. Sequencing must be explicitly described in the response, not assumed.

   AP Computer Science Principles scoring guidelines 2022 to 2024, Row 5 criteria and College Board reader commentary

5. 05

   Submitting two test cases that use the same input type or category rather than different argument values

   Row 6 requires two test cases with different input values, and the difference must be meaningful: the two inputs should test different conditions or behaviors, not simply be two instances of the same type of valid input. Per the scoring guidelines, two test cases that both use non empty string inputs of the same category (for example, two different genre names with the same playlist) are less likely to earn Row 6 than test cases that exercise genuinely different conditions (for example, an empty input versus a populated input, or an input that produces a result versus one that produces no result). College Board reader commentary across multiple years identifies test cases that differ only in the surface value of the input, without testing different behaviors, as a frequent source of Row 6 losses.

   AP Computer Science Principles scoring guidelines 2022 to 2024, Row 6 criteria and College Board reader commentary

6. 06

   Confusing program purpose with program function, losing Row 1

   Row 1 requires students to correctly identify both program purpose and program function, and many responses conflate the two or describe only one. Program purpose is the problem the program solves or the goal it serves: why it was created. Program function is what the program does when it runs: the specific behavior observable in the output. A response that writes only what the program does (function) without identifying why it exists (purpose) does not earn Row 1. Per College Board's scoring guidelines, the most frequently not earned version of this error is describing the program's mechanics (what happens step by step) without ever stating the problem being solved or the audience being served. The fix is a single sentence that states the purpose before describing the function.

   AP Computer Science Principles scoring guidelines 2022 to 2024, Row 1 criteria

How do you prepare effectively for the AP CSP Create Performance Task?

The highest return preparation is reading the official scoring guidelines for 2023 and 2024 and the sample student submissions with reader commentary, then drafting your own PPR responses and checking them row by row against the rubric.

Unlike timed exam sections where practice under time pressure is the primary training method, the Create PT rewards deliberate iteration over weeks. Start by reading the College Board scoring guidelines for a recent year, both of which are linked from this page. The guidelines include the exact rubric language for each row plus sample scored responses showing what earns and what does not. After reading, draft your two PPR responses as if submitting them today, then check each response against the row criteria: Row 2 asks whether you have two distinct code segments; Row 3 asks whether your complexity explanation is program specific; Row 5 asks whether you have explicitly described sequencing, selection, and iteration by name. Students who check their drafts against the row criteria before the April 30 deadline consistently earn more rubric points than students who submit responses written only from memory of general rubric guidance. The 2023 sample submissions document linked from this page includes responses at the 3 of 6, 4 of 6, and 5 of 6 score levels with annotated reader commentary explaining every row that was and was not earned. That annotation is the single most efficient preparation tool available at no cost.

1. 1

   Choose a program idea early in the school year and stick with it. The Create PT is scored on what you submit by April 30, not on what you intended to build. Students who pivot their program topic late in the year often submit incomplete or poorly documented work because they have less time to develop meaningful list use and algorithm complexity.

2. 2

   Build your program around a list from the beginning. The data abstraction response (Rows 2 and 3) requires a list that genuinely manages complexity in your program. Retrofitting a list into a finished program often produces a list that does not meaningfully reduce complexity, which loses Row 3. Design the program so the list is central to how it works, not an add-on.

3. 3

   Write your own algorithm logic. Do not select a procedure that delegates all work to built in functions. Your Row 5 procedure must contain a student written loop (iteration) and a student written conditional (selection). If your procedure body is mostly library calls, rewrite it so the core logic is yours, calling the library only for input and output operations.

4. 4

   Draft your PPR responses before the submission deadline and read each response against the rubric criteria published in the scoring guidelines. For Row 3, ask yourself: have I explained what would be harder about my specific program if I had not used a list? For Row 5, ask yourself: have I identified and explained sequencing, selection, AND iteration by name?

5. 5

   Pick two test cases that test genuinely different conditions. The best test cases for Row 6 test edge cases: an empty input, the maximum input, an input that should return nothing, and an input that should return something. Two test cases that differ only in which valid value you entered are weaker than cases that exercise different branches of your program logic.

6. 6

   Distinguish purpose from function in your Row 1 response. Write one sentence that states what problem your program solves or what goal it serves (purpose). Then write one or two sentences describing what the program does when run (function). If you find yourself writing only about what the program does, add a sentence before it that starts with: this program was designed to solve or this program exists to help.

7. 7

   Do not describe your procedure in abstract or general terms in Response 2. Instead of writing that the procedure processes data and returns a result, describe the specific steps of your specific algorithm: what it initializes, what condition it checks in the loop, what it adds or modifies when the condition is true, and what it returns. Use the variable names and operation names from your actual code.

8. 8

   Read at least two sample submissions from the College Board archive before submitting your PPR. The sample submissions for 2023 and 2024 are linked from this page and include reader commentary explaining why each row was or was not earned. Reading a sample that earned 4 out of 6 and understanding which two rows it missed is more efficient preparation than re-reading the rubric criteria alone.

AP Computer Science Principles Create Performance Task FAQ

More AP Computer Science Principles resources