AP CSP’s Personalized Project Reference: How the Create Task Changed and What You Submit Now
Updated: 4 days ago
The AP CSP Personalized Project Reference (PPR) is a student-prepared reference that contains selected code segments and information from the Create Performance Task for use when answering the exam’s written-response questions. Students must prepare their PPR based on their Create Task and follow the College Board’s submission and formatting requirements. EduShaale’s AP CSP Personalized Project Reference guide explains how the Create Task and PPR requirements work, what has changed, what students need to include, and how to prepare the reference correctly for the AP exam.
Serious About Your AP Scores? Let’s Get You There
From understanding concepts to scoring 4s and 5s, EduShaale’s AP coaching is built for results — with personalised learning, small batches, and exam-focused strategy.
3 Components in the current Create Task submission -- code, video, PPR | 2 Sections inside every PPR -- Procedure and List | 4 Written-response prompts answered using the PPR on exam day | 0 Comments allowed anywhere in the PPR -- one violation zeroes the whole task |
Fall 2023 When College Board introduced the PPR and moved written responses to exam day | 10pt Minimum legible font size for every PPR screen capture | 60 min Time to answer all four prompts using the PPR, after the multiple-choice section | Apr 30 2026 deadline to submit the PPR as final in the AP Digital Portfolio |
Table of Contents
Introduction: The Document Most Students Build Last and Need Most
Of the three files a student uploads for the AP CSP Create Performance Task, the Personalized Project Reference is the one most often finished in the last twenty minutes before the April 30 deadline -- and it is also the only one that follows a student into the exam room. The program code and video get built, tested, and mostly forgotten. The PPR is different: whatever four screen captures a student submits are exactly what sits in front of them, and nothing else, during the 60-minute written-response section weeks or months later.
That mismatch between how little time the PPR usually gets and how much it actually decides is compounded by a second problem: a large share of AP CSP prep material online still describes a version of this task that stopped existing after the 2023 exam. Search results, older teacher handouts, and forum answers routinely describe writing a full essay-style response and submitting it through the Digital Portfolio months in advance -- a process College Board replaced with the Personalized Project Reference and a proctored exam-day writing session starting with the 2024 administration.
Following outdated instructions here does not just waste time; it can mean walking into the exam with a reference document built for a submission format that no longer exists.
This guide is scoped specifically to the Personalized Project Reference -- what it replaced, why it exists in its current form, exactly what its two sections require, the formatting rules College Board actually enforces (including the one that can zero out an entire task), and how its contents connect to the written-response prompts answered on exam day. For the full Create Performance Task -- the 6-point rubric, the video and program-code requirements, the AI policy, and a complete preparation timeline -- see EduShaale’s complete AP CSP Create Performance Task guide, which this post supplements rather than repeats.
1. What Is the AP CSP Personalized Project Reference?
The AP CSP Personalized Project Reference (PPR) is a short, student-authored document containing four screen captures of a student’s own program code -- not the full program, and not a written explanation, just the specific code segments College Board requires. It is one of three components submitted for the Create Performance Task, alongside the full program code file and a short video, and it is due through the AP Digital Portfolio by the same April 30 deadline as the other two.
What makes the PPR different from the other two components is what happens to it afterward. The program code and video are submitted and then effectively archived until scoring. The PPR is returned to the student on exam day and becomes the only reference material available while answering the four written-response prompts -- no notes, no access to the original code file, nothing else. A student who builds a confusing or incomplete PPR is not just risking points on the document itself; they are handing their exam-day self a worse tool to work with.
PPR vs. program code: not the same submission It is easy to assume the PPR is just a shorter version of the full program code file. It is not. The program code component is the complete, unedited PDF of the finished program. The PPR is a curated set of four specific excerpts from that code -- selected by the student, screen-captured individually, and stripped of every comment -- built specifically to support the written-response prompts answered later. Submitting the full code file in place of a proper PPR, or vice versa, does not satisfy either requirement. |
2. Three Eras: How the Create Task’s Written Component Has Evolved
The PPR is not how the Create Performance Task has always worked, and understanding what it replaced explains most of the rules that confuse students today.
Era 1: Two performance tasks, portfolio-only writing (through the 2023 exam)
For most of AP CSP’s history, the exam had three graded components rather than two: an Explore Performance Task, worth roughly 14-16% of the score, in which students researched a computing innovation and wrote about its impact; a Create Performance Task, worth around 24%; and the end-of-course multiple-choice exam, worth about 60%. Official College Board and school-published handouts dated as recently as fall 2020 describe this structure, and the Create Performance Task’s written response at that time was submitted entirely through the Digital Portfolio months before the exam -- structured in labelled parts (a purpose statement, code-segment explanations, and a testing response) alongside the video and code, with no writing component happening on exam day at all.
Era 2: Explore Performance Task discontinued
At a later point, College Board discontinued the Explore Performance Task and redistributed its weight, folding it into the multiple-choice section and the Create Performance Task. This is the change responsible for one of the most common points of confusion in older materials: score-weighting figures like "Explore 16% / Create 24% / Exam 60%" belong to a version of the course that no longer exists, and any resource still citing them predates this shift.
Era 3: The Personalized Project Reference and exam-day writing (2024 onward)
Effective for the 2024 exam administration, College Board removed the portfolio-based written response entirely. In its place: the three-component submission described throughout this guide -- program code, video, and PPR -- with the actual writing moved to a proctored, 60-minute session built into the end-of-course exam itself, answered using only the PPR. This is the version of the Create Performance Task every current AP CSP student is working under, and it is the version the rest of this guide describes.
3. Why College Board Redesigned It for 2024
College Board has been explicit about the reasoning behind the Era 3 shift: reduce the risk of inappropriate AI use in a component that, under the old format, was written entirely at home with no supervision and submitted weeks or months before the exam. A take-home essay about a program’s purpose and design is straightforward to generate with an AI tool with little way to verify authorship after the fact. A 60-minute, proctored writing session that draws on a document the student built themselves is a fundamentally harder thing to outsource.
The PPR is the hinge the whole redesign turns on Removing the take-home essay only works if something replaces it as the student’s reference material on exam day -- otherwise nobody could reasonably answer detailed questions about code written months earlier from memory alone. The PPR is that replacement: a compact, official record of exactly which procedure and which list the student is prepared to discuss, carried into the exam room instead of trusted to memory. Every formatting rule covered in the rest of this guide exists to keep that record legible, fair, and free of information that would give an unfair advantage over a version built entirely from memory. |
4. The Two Sections of the PPR, Part by Part
Every PPR has exactly two sections, and each section has exactly two parts -- four screen captures total, no more and no fewer.
Section | Part | What the screen capture must show |
Procedure | (i) Definition | A student-developed procedure: its name and return type (where relevant), at least one explicit parameter that affects the procedure’s functionality, and an algorithm that uses sequencing, selection, and iteration |
| (ii) Call | Where that same procedure is called elsewhere in the program |
List | (i) Storage | How data is stored in a list or other collection type -- the code that creates or populates it |
| (ii) Use | That same list’s data being accessed or used toward the program’s purpose, elsewhere in the code |
A few structural details matter here beyond just having four screenshots. The procedure captured in part (i) does not need a parameter to satisfy the Program Requirements scoring point covered in EduShaale’s main Create Performance Task guide, but the task directions do ask for one, and the exam-day prompts are written assuming one exists -- a procedure with a parameter that visibly changes the output is safer on both counts. The call in part (ii) has to be consistent with the procedure header defined in part (i); a mismatched name, argument count, or type is one of the more mechanical ways this section loses credit. The same logic applies to the List section: the storage segment in part (i) and the use segment in part (ii) need to be genuinely connected, not two unrelated pieces of list-handling code from different parts of the program.
5. Formatting Rules That Are Actually Enforced
Beyond the four required screen captures, College Board’s task directions and Personalized Project Reference guidance set specific formatting expectations. None of these are stylistic suggestions -- they are the difference between a Reader being able to score the document and a segment being unreadable.
Genuine screen captures, not retyped code: each segment has to be an actual screenshot of the code as it exists in the development environment, not code retyped into a document or image editor.
Minimum 10-point font: text smaller than this is treated as illegible, regardless of whether the code itself is correct.
Not blurry: low-resolution screenshots, especially from mobile devices or heavily zoomed-out editors, are a recurring, avoidable submission error.
Cropped to the relevant logic: each capture should show the code segment clearly without unrelated surrounding code cluttering the frame, though enough context to make the segment’s role clear is worth keeping.
Student-authored: even when the underlying code was developed with a partner, the PPR itself -- which segments are chosen and how they are captured -- must be each student’s own individual work.
6. The Zero-Score Trap: No Comments, No Course Content
One rule sits above every other formatting requirement in terms of consequence: the Personalized Project Reference cannot contain comments in the code, or any other course content, anywhere in the document. Not a brief note explaining what a line does. Not a citation comment for an AI tool or external source -- those belong in the separate program code file, not here. Not a leftover TODO or debugging print statement with an explanatory comment attached.
What happens if this rule is broken College Board’s own student directions state plainly that including comments or course content in the Personalized Project Reference results in a score of zero for the entire Create Performance Task -- not a deduction on the affected screenshot, not a lost point on one rubric row, but zero across all six points, including the written-response prompts answered later using that same document. This is, by a wide margin, the highest-stakes single mistake available in the entire task. |
The reason this trips up well-prepared students specifically is that good coding practice cuts the opposite direction. Students spend months being taught to comment their code clearly, then have to deliberately strip every comment out of exactly four screenshots before submission -- an easy step to forget under deadline pressure, especially if the PPR is assembled in the final hour before the portfolio closes.
A pre-submission check worth doing twice
Open each of the four screen captures at full size and read every visible line, not just the code you intended to include.
Check specifically for citation comments -- these are the most common accidental inclusion, since they are added deliberately and easy to forget to remove from a screenshot.
Confirm no header comments, docstrings, or block comments from earlier development are still visible above or below the captured segment.
Re-check after any last-minute code edit -- a comment added while debugging two days before the deadline is exactly the kind of thing this rule catches.
Need a second pair of eyes on your PPR before you submit? EduShaale’s 1-on-1 AP Computer Science coaching includes a dedicated compliance review -- catching stray comments and weak segment choices before the April 30 deadline, not after. |
7. How Your PPR Sections Map to the Exam-Day Prompts
The four written-response prompts answered on exam day -- Written Response 1, 2(a), 2(b), and 2(c) -- each draw on a specific part of the PPR, but the exact mapping is less fixed than most study guides suggest, and knowing where it varies changes how a student should prepare.
Prompt | Category | PPR section it draws from |
Written Response 1 | Program Design, Function, and Purpose | The program and video generally -- not anchored to one PPR section |
Written Response 2(a) | Algorithm Development | Consistently the Procedure section -- specifically the first selection statement |
Written Response 2(b) | Errors and Testing | Varies by exam form -- Procedure section on some forms, List section on others |
Written Response 2(c) | Data and Procedural Abstraction | Varies by exam form -- whichever section 2(b) does not use |
Why this matters more than it looks like it should Comparing the two official 2025 exam forms directly shows the pattern: on one form, Written Response 2(b) drew on the Procedure section and 2(c) drew on the List section; on the other, 2(b) drew on the List section and 2(c) drew on the Procedure section. College Board confirms scoring guidelines and prompts are unique each year and not released in advance. The practical takeaway is that a student cannot predict in advance which of their two sections 2(b) will test and which one 2(c) will test -- only that, between the two prompts, both sections will be tested. Preparing to explain testing and abstraction fluently for the Procedure section alone, on the assumption it will always be 2(a) and 2(c)’s job to cover the rest, leaves a real chance of being caught unprepared on exam day. |
The practical implication for preparation is straightforward: rehearse errors-and-testing and abstraction explanations for both the Procedure and List sections, not just one. Section 8 builds this into a step-by-step approach.
8. Building a Compliant PPR: A Step-by-Step Walkthrough
This sequence assumes the program itself is largely finished and focuses specifically on turning it into a PPR that survives both scoring and the exam-day writing session.
Choose the procedure first. Pick the single procedure that most clearly demonstrates a parameter genuinely affecting the output, plus real sequencing, selection, and iteration. If more than one candidate exists, choose the one that is easiest to explain in three sentences -- Section 7 explains why that matters for the written response.
Choose the list next. Pick a list that is both written to and read from -- filtered, searched, iterated, or otherwise actually used -- not just created and appended to. Confirm it connects to the program’s actual purpose, not a side feature.
Capture the procedure’s definition and its call. Two separate screenshots: the full procedure header and body, and a second showing where it is called elsewhere in the program with matching arguments.
Capture the list’s storage and its use. Two more screenshots: where the list is created or populated, and where its contents are accessed or acted on toward the program’s purpose.
Strip every comment from all four captures. Run the pre-submission check from Section 6 on each screenshot individually, not just once over the whole document.
Check legibility at actual size. View each capture at the size a Reader would see it -- not zoomed in on your own screen -- and confirm the font is comfortably above the 10-point minimum and nothing is blurry.
Upload, mark final, and attest originality for all three components. The PPR, video, and program code are submitted and finalised separately; missing the final step on any one of them means it is not sent for scoring.
Practise against the finished document, not the code in your head. Once finalised, write timed responses to Procedure-anchored and List-anchored testing and abstraction prompts using only the PPR -- exactly the constraint the real exam imposes.
9. Where the 2025 National Data Shows PPR Points Being Lost
The College Board’s 2025 Chief Reader Report ties several of the most common national point losses directly to how the PPR itself was constructed, not just to weaknesses in the written explanations built on top of it.
Event handlers submitted in place of a procedure: especially common in block-based languages, where a built-in event handler looks similar to a student-developed procedure but does not satisfy the requirement -- and is one of the most frequently cited reasons the Program Requirements point (85% national average) is lost.
Lists that are stored but never genuinely used: a list that is created and appended to, but never read from, filtered, or iterated in a way that affects the program, does not satisfy the "use of the list" requirement -- a PPR built around this kind of list cannot be fixed by better writing later.
Responses that reference code outside the identified segment: Chief Reader commentary specifically flags responses describing a modification to code that was not actually part of the referenced PPR section -- for example, discussing a change outside the list’s part (ii) segment when the prompt is scoped to that segment. This is a navigation error, not a conceptual one: the student understood the concept but answered about the wrong piece of their own document.
Confusing which section a prompt is scoped to: because Written Response 2(b) and 2(c) can each draw from either the Procedure or the List section depending on the exam form (Section 7), some responses answer using the wrong section’s logic entirely -- a mistake that is easy to avoid by rereading the prompt’s wording against the PPR before writing, but costly when missed under time pressure.
The common thread None of these four patterns are failures of understanding computer science. Every one of them is a construction or navigation problem with the PPR itself -- the wrong kind of code segment chosen, a list included but not truly used, or a response that answers about the wrong part of the document. All four are fixable at the building stage, well before exam day, which is exactly why Section 8’s sequence puts segment selection before anything else. |
10. Old Format vs. Current Format at a Glance
Element | Era 1 (through 2023 exam) | Current (2024 onward) |
Performance tasks | Two -- Explore and Create | One -- Create only |
Written response | Full essay-style response, submitted through the Digital Portfolio | Four prompts answered live, 60 minutes, on exam day |
Reference document | Not applicable | Personalized Project Reference (PPR) -- screen captures, no comments |
Approximate score weighting | Explore ~15%, Create ~24%, exam ~60% | Create Performance Task 30%, exam 70% |
AI-use policy | Not formally addressed in current terms | Explicitly allowed in development with citation in the code file; not allowed during exam-day writing |
Where writing happens | Entirely outside any supervised setting | Development is unsupervised; final writing is proctored |
The throughline across every change is the same: College Board has moved steadily toward a format where the final, scored explanation of a student’s work happens under supervision, using a document the student built and controls, rather than as an unsupervised essay. The PPR is the mechanism that makes that possible.
Ready to Start Your AP Journey?
EduShaale’s AP Coaching Program is designed for students aiming for top scores (4s & 5s). With expert faculty, small batch sizes, personalized mentorship, and a curriculum aligned to the latest AP format, we help you build deep conceptual clarity and exam confidence.
Subjects Covered: AP Calculus, AP Physics, AP Chemistry, AP Biology,
AP Economics & more
📞 Book a Free Demo Class: +91 90195 25923
🌐 www.edushaale.com/ap-coaching
Free Diagnostic Test: testprep.edushaale.com
11. Frequently Asked Questions
Q: What’s the difference between the PPR and the program code I submit?
A: The program code component is the complete, unedited file of your finished program, submitted as a PDF. The PPR is a separate, much shorter document -- four specific screen captures selected from that code, with every comment removed, built specifically to serve as your reference during the exam-day written response. They are scored differently, and submitting one in place of the other does not satisfy either requirement.
Q: Do I need to include a parameter in my procedure for the PPR?
A: The Program Requirements rubric point technically does not require a parameter to be earned. However, the task directions ask for a procedure with at least one explicit parameter that affects functionality, and the exam-day prompts are written assuming one exists. Including a genuine, functionality-affecting parameter is the safer choice even though it is not strictly required for that one point.
Q: Can I use a different procedure or list than what’s in my final program code?
A: The segments in your PPR should come directly from your actual, final submitted program and match what appears in your program code component. Using a procedure or list that does not actually appear in your final code, or that has since been modified, creates an inconsistency that can cost points if a Reader checks the full program code file to verify.
Q: What happens if I forget to submit my PPR by the deadline?
A: Only components submitted as final by the April 30 deadline are sent for scoring. If your PPR is not submitted as final, you will not have it available as a reference during the exam-day written response, and you will not earn credit for any of the written-response prompts that depend on it.
Q: Do my procedure and my list need to be related to each other?
A: No. The Procedure and List sections are scored independently and do not need to interact with or reference one another. What matters within each section is that the procedure genuinely uses its parameter and demonstrates real algorithmic structure, and that the list is genuinely stored to and read from -- not that the two sections connect to each other.
Q: Can I revise my PPR after submitting it as final?
A: No. Once any component is submitted as final in the AP Digital Portfolio, it cannot be revised. This is worth taking seriously specifically for the PPR, since it is the exact document you will be working from, unchanged, during the exam-day written response months later.
Q: If I worked with a partner, whose procedure and list go in my PPR?
A: You can collaborate with a partner on developing the program code itself, but the Personalized Project Reference has to be each student’s own individual work -- which segments are selected, how they are captured, and the document submitted. Two students who worked together on the same program typically build their own separate PPRs, and may highlight different segments of the shared code.
Q: What’s the single most common reason PPRs lose points?
A: Based on the 2025 Chief Reader Report, the most frequent PPR-construction issues are choosing a list that is stored but never genuinely used, and submitting an event handler in place of a real student-developed procedure -- both covered in Section 9. Neither is a writing problem; both are choices made before the written response is ever attempted.
Q: Will I know in advance whether Written Response 2(b) or 2(c) tests my Procedure or List section?
A: No. College Board confirms that scoring guidelines and prompts are unique each exam year and not released in advance, and the two official 2025 exam forms tested the two sections in opposite arrangements for 2(b) and 2(c). The safer preparation is rehearsing testing and abstraction explanations for both sections rather than assuming a fixed pattern.
Q: Is the PPR the same thing as "Component C" mentioned in older AP CSP materials?
A: Yes. Some College Board and curriculum-provider materials refer to the program code, video, and Personalized Project Reference as Components A, B, and C respectively. "Component C" and "Personalized Project Reference" refer to the same submission.
Q: Can I use AI to help decide which code segments to include in my PPR?
A: College Board’s current policy allows AI assistance during program development, provided it is cited in a comment within the full program code file -- not the PPR, which cannot contain any comments at all. Using AI purely to help decide which already-written segments best demonstrate the required elements falls within that same development-phase allowance, but the final document must still be each student’s own individual work, free of any comments.
Q: How is the PPR different from what AP CSP required before 2024?
A: Before 2024, there was no PPR: students submitted a full written response directly through the Digital Portfolio months before the exam, alongside the video and code, and no writing happened on exam day at all. The PPR replaced that written response with a comment-free reference document, and the actual writing moved to a proctored, 60-minute session on exam day. Section 2 covers this history in full.
12. EduShaale -- Expert AP Computer Science Coaching
EduShaale provides 1-on-1 AP Computer Science coaching that treats the Personalized Project Reference as a distinct, gradable skill -- not an afterthought assembled in the final hour before the portfolio closes.
PPR Segment Selection Coaching: sessions dedicated to choosing a procedure and list that satisfy every technical requirement before a single screenshot is taken, using the sequence in Section 8.
Compliance Review: a dedicated check for stray comments and course content before submission -- closing off the single mistake that can zero out an entire Create Performance Task.
Dual-Section Rehearsal: since Written Response 2(b) and 2(c) can test either section depending on the exam form, we drill testing and abstraction explanations for both the Procedure and List sections, not just one.
Old-vs-Current Format Correction: for students or parents whose expectations were set by outdated materials, we walk through exactly what changed and what the current submission actually requires.
Free AP Computer Science Diagnostic Assessment -- testprep.edushaale.com
Free Consultation -- Personalized Project Reference Build Review
Live Online 1-on-1 AP Computer Science Coaching -- edushaale.com/advanced-placement
WhatsApp +91 9019525923 | edushaale.com | info@edushaale.com
EduShaale’s core observation The PPR takes the least time of the three Create Performance Task components to build and produces the most consequence if built poorly. Students who treat it with the same care as the code itself -- choosing segments deliberately, checking for comments twice, and rehearsing against the finished document before exam day -- consistently outperform students who assemble it as a formality in the final hour before the deadline. |
13. References & Resources
Official College Board resources
EduShaale AP resources
© 2026 EduShaale | edushaale.com | info@edushaale.com | +91 9019525923
AP®, Advanced Placement®, and AP Computer Science Principles® are registered trademarks of the College Board, which was not involved in the production of, and does not endorse, this guide or EduShaale.
Historical score-weighting figures for the discontinued Explore Performance Task are approximate, drawn from archived teacher and student handouts rather than a single current official source, and are provided for context only. All current-year deadlines, formatting rules, and requirements should be verified against apcentral.collegeboard.org and apstudents.collegeboard.org before relying on them for submission or exam-day planning.
This guide is for educational purposes only and does not constitute legal, financial, or college admissions advice.
Comments