The AP CSP Create Performance Task: A Complete Guide to the 30% Most Students Underprepare
Updated: 3 days ago
The AP CSP Create Performance Task is a student-developed programming project worth 30% of the AP Computer Science Principles score. Success depends on meeting the specific College Board requirements for the program code, video, Personalized Project Reference, and written responses—not simply creating a working application. Students need to plan their project carefully, document the required code segments, and practise explaining how their program works.
EduShaale supports AP CSP students with personalised coaching, project guidance, and exam-focused preparation, helping them understand the Create Task requirements, strengthen their programming skills, and prepare the required responses with greater confidence.
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.
30% Share of your AP CSP score that comes from the Create Performance Task | 175,935 Students who sat the AP CSP exam in 2025 (College Board, official) | 61.7% 2025 pass rate (score of 3+) -- official College Board data | 6 points Total raw points available across the Task and Written Response |
0.95 Mean score (out of 1) on the Video row -- the easiest of the six, 2025 | 0.40 Mean score (out of 1) on Written Response 2(c) -- the hardest, 2025 | 9 hrs Minimum in-class time College Board requires for the Task | 60 min Time to answer all four written-response prompts, on exam day |
Table of Contents
Introduction: The Points Aren’t Where Students Think They Are
Most students preparing for the AP CSP Create Performance Task spend nearly all their effort on the part they can already do well. According to the College Board’s own 2025 Chief Reader Report, 95% of students earned the point for their video and 85% earned the point for meeting the program’s technical requirements -- a working procedure, a list, selection, and iteration. Those are the parts a student controls by writing code that runs. The written response is a different story: only 45% of students earned the point for explaining a Boolean expression, and just 40% earned the point for explaining how a procedure manages complexity. Students routinely build software that works and then lose more than half the exam’s most heavily weighted written points explaining it.
That gap matters because of how the score is built. The Create Performance Task is worth 30% of the final AP CSP score -- but since the 2024 redesign, only 10 of those 30 percentage points come from the code, video, and Personalized Project Reference a student submits months in advance. The other 20 points depend entirely on a 60-minute writing session that happens on exam day, after the multiple-choice section, using nothing but a self-authored reference sheet and memory of a program written back in the autumn. Students train hardest for the part of the task they already do well on, and barely rehearse the part that carries twice the weight and produces less than half the score.
This guide is built from the College Board’s own 2025 scoring guidelines and Chief Reader Report -- not estimates, and not the generic advice that circulates in most AP CSP prep content. It breaks down exactly how each of the six rubric points is earned, what changed in the 2024 redesign and why, the current policy on AI tools, precisely where the national data shows students losing points, and a realistic plan for using the required nine hours of class time plus the practice that has to happen outside it.
1. What Is the AP CSP Create Performance Task?
The AP CSP Create Performance Task is a through-course assessment built into the AP Computer Science Principles exam. Instead of answering a fixed set of questions in a single sitting, a student spends at least nine hours of class time across the school year designing, building, and documenting an original computer program of their own choosing -- one that addresses a need, a concern, a personal interest, or a creative idea. The program can be written in any language: text-based options like Python and JavaScript are common, but block-based environments such as Scratch and Snap! are explicitly permitted too.
Three components go to College Board through the AP Digital Portfolio, all due by 11:59 p.m. ET on April 30 in the year of the exam: the full program code, a short video of the program running, and a Personalized Project Reference (PPR) containing specific screen captures of the code. Then, on exam day itself, the student answers four written-response prompts about that same program using the PPR as their only reference material. Together, this task is worth 30% of the final AP CSP score -- a bigger share than any single component of most other AP exams carries.
Why this task makes AP CSP different from almost every other AP exam AP Computer Science Principles is one of only three AP courses -- alongside AP Seminar and AP Research -- where College Board requires enrolment in a formal AP course section specifically because of the performance-task component. A student cannot simply register for the end-of-course exam the way they can for AP Calculus or AP Chemistry; the Create Performance Task has to be completed inside a school’s AP Digital Portfolio system with a teacher providing the required class time. That single structural fact changes how CSP prep has to be planned, and it is the reason self-study routes that work for exams like AP Computer Science A do not transfer cleanly to CSP. |
2. The 2024 Redesign: Why the Written Response Moved to Exam Day
If a syllabus, an older prep book, or an internet search result describes writing five short essays and uploading them alongside a video, it is describing the version of this task that no longer exists. Before the 2023–24 school year, the written response was submitted through the AP Digital Portfolio as part of the through-course package, at the same time as the code and video. Starting with the 2024 exam administration, College Board removed that portfolio-based written response entirely and replaced it with a new, timed writing session built into the end-of-course exam itself.
Under the current structure, a student no longer writes about their program months before the exam. Instead, they submit a Personalized Project Reference -- screen captures of specific code segments, with no explanatory comments allowed -- and then, on exam day, after finishing the multiple-choice section, they get 60 minutes to answer four written-response prompts about that code using only the PPR and the College Board reference sheet in front of them.
The stated reason for the change College Board has been explicit that this redesign was intended to let students explain their own code more directly and to reduce the risk of inappropriate AI use in a component that used to be written entirely outside any supervised setting. Answering live, from a reference sheet the student authored, is harder to outsource than a take-home essay submitted weeks in advance -- which is also why current guidance explicitly allows AI assistance during the coding phase itself, as long as it is cited (covered in Section 9), while the exam-day writing is entirely the student’s own, unaided work. |
What changed versus what stayed the same
Element | Before 2024 | Current (2024 onward) |
Written response | Submitted through the Digital Portfolio, months before the exam | Answered live on exam day, 60 minutes, after the multiple-choice section |
Reference document | Not applicable | Personalized Project Reference (PPR) -- screen captures, no comments |
Video | Required, part of the portfolio | Still required, still part of the portfolio -- unchanged |
Program code | Required, part of the portfolio | Still required, still part of the portfolio -- unchanged |
In-class time | At least 12 hours in earlier guidance | At least 9 hours, per current College Board directions |
Total weight | 30% of final AP score | 30% of final AP score -- unchanged |
The practical takeaway is simple: any prep material that talks about writing your Create Task response as homework, uploading five essays, or having weeks to revise your written answers is describing a format that has not been used since the 2023 exam. If a resource does not mention the Personalized Project Reference or the 60-minute exam-day writing window, treat it as outdated and verify anything it claims against the current AP Computer Science Principles Course and Exam Description before relying on it.
3. The Three Components You Submit
All three components are submitted separately in the AP Digital Portfolio, and each must be individually marked final -- including an originality attestation for each one -- before the April 30 deadline. A component that is uploaded but never marked final is not sent for scoring.
Component A: Program code
A complete PDF of the finished program, in whatever language it was built in. The code must be student-developed: calls to existing libraries or starter code are allowed, but they need to be clearly attributed in comments, and built-in event handlers are not considered student-written even when a student assembles the surrounding logic around them.
Component B: Video
A short video -- College Board task directions have specified roughly a minute -- that demonstrates the program actually running: input going in, the program responding, and output coming out. Screenshots or storyboards do not satisfy this requirement, and neither does a video that only scrolls through code without showing it execute. If the source of the input is not visible on screen (a keystroke, a file, a sensor), the reviewer is allowed to check the full program code to confirm it, but the safer approach is to make the input source obvious on camera or to caption it.
Component C: Personalized Project Reference
This is the document a student will have in front of them on exam day, and it is the single highest-stakes upload of the three. It requires four specific screen captures: a student-developed procedure definition that uses at least one explicit parameter and demonstrates sequencing, selection, and iteration; a call to that procedure; a code segment showing how data is stored in a list (or other collection type); and a code segment showing that same list being used toward the program’s purpose. Screen captures need to be legible -- not blurry, at least 10-point font -- and cropped tightly enough to show the relevant logic.
The single costliest mistake in this entire task The Personalized Project Reference cannot include comments in the code or any other course content -- no explanatory notes, no annotations, nothing beyond the raw code segments themselves. College Board’s own student directions state plainly that including comments or course content in the PPR results in a score of zero on the entire Create Performance Task, not just a deduction on the affected row. Every point in Section 4 becomes unreachable. This is worth checking twice before the April 30 submission, because it is an easy rule to forget after months spent writing well-commented code as a matter of good practice. |
4. How the Task Is Scored: The Complete 6-Point Rubric
The Create Performance Task and its written response are scored on six binary rubric points -- each row earns either its full point or nothing, with no partial credit within a row. Each point is worth exactly 5 percentage points of the final AP score (30% divided across 6 points), so the six rows split cleanly into two groups: the two "course project" rows built from the code and video are worth 10% of the total AP score, and the four written-response rows answered on exam day are worth the other 20%.
# | Rubric row | Scored from | Worth |
1 | Video | Course project video (or program code if unclear) | 5% of AP score |
2 | Program Requirements | Personalized Project Reference (or full code if needed) | 5% of AP score |
3 | Written Response 1: Program Design, Function, and Purpose | Video + Written Response 1 | 5% of AP score |
4 | Written Response 2(a): Algorithm Development | PPR + Written Response 2(a) | 5% of AP score |
5 | Written Response 2(b): Errors and Testing | PPR + Written Response 2(b) | 5% of AP score |
6 | Written Response 2(c): Data and Procedural Abstraction | PPR + Written Response 2(c) | 5% of AP score |
Source: College Board, AP Computer Science Principles 2025 Scoring Guidelines (official rubric structure, current for the 2025-26 cycle).
What each row actually requires
Video (row 1): the video shows the program running with visible input, functionality, and output. A point is not awarded if the video never shows the program actually executing.
Program Requirements (row 2): the code includes a student-developed procedure, a call to it, a list or collection, a use of that list, selection, and iteration -- and none of those elements can be trivial or disconnected from what the program actually does. A parameter is not required to earn this specific point, even though the task directions ask for one.
Written Response 1 (row 3): the response identifies a valid output of the program and explains how it demonstrates the program’s functionality -- evaluated together with the video.
Written Response 2(a) (row 4): the response identifies the Boolean expression in the first selection statement in the Procedure section of the PPR, gives a specific value that makes it evaluate true or false (depending on the exam form), and explains why.
Written Response 2(b) (row 5): the response describes a modification to the code in the PPR’s list section that would cause a genuine logic error, and explains how the program’s behaviour would change.
Written Response 2(c) (row 6): the response explains how the identified procedure manages complexity -- specifically why implementing that functionality as a procedure makes the program easier to maintain, not just what it does for the user.
5. Where Students Actually Lose Points: 2025 National Data
College Board publishes a Chief Reader Report after every exam administration, written by the exam’s Chief Reader based on what readers actually saw across hundreds of thousands of scored responses. The 2025 report -- covering 175,935 scored Create Performance Tasks -- gives the clearest available picture of exactly where the national cohort gains and loses points.
Rubric row | Mean score (/1) | % earning the point | Difficulty |
Video | 0.95 | ~95% | Easiest |
Program Requirements | 0.85 | ~85% | Easy |
Written Response 1 | 0.78 | ~78% | Moderate |
Written Response 2(b): Errors and Testing | 0.62 | ~62% | Moderate-hard |
Written Response 2(a): Algorithm Development | 0.45 | ~45% | Hard |
Written Response 2(c): Data and Procedural Abstraction | 0.40 | ~40% | Hardest |
Source: College Board, 2025 AP Computer Science Principles Chief Reader Report (Set 2), official mean scores per rubric row.
The number that summarises the whole problem Add the six 2025 mean scores together and the average student earned about 4.04 of the 6 available points -- roughly 67% of the Create Performance Task’s total value. That leaves close to a third of the task’s 30% share of the AP score unclaimed by the average test-taker, and the data above shows precisely where: not in the video or the code, but in three of the four written-response prompts. |
What actually goes wrong, row by row
Video: the rare miss is a video that shows a program on screen but never demonstrates it receiving input -- a game board that appears but is never clicked, for instance -- or a video that scrolls through code without ever running it.
Program Requirements: the most common misses are relying on a built-in event handler instead of an actual student-written procedure, building a list that data is added to but never read back from, and using a loop that only ever runs once or runs unconditionally forever without a real exit condition -- none of which count as genuine iteration or a genuine procedure under the rubric.
Written Response 1: students often assert that invalid input is impossible without explaining why, or mislabel a normal, already-handled case -- like a "not enough funds" message a program is designed to show -- as if it were unexpected input rather than intended functionality.
Written Response 2(a) -- the hardest single point after data abstraction: many responses describe the general idea of a condition instead of stating the actual Boolean expression, give a vague category of values instead of one specific value, skip the explanation of why that value produces the result, or -- a purely mechanical error -- answer about a later selection statement instead of the first one in the Procedure section.
Written Response 2(b): a frequent miss is describing a change to code that is not actually part of the PPR’s list section, or naming a change without explaining how the program’s behaviour would differ afterward. Chief Reader commentary specifically flags one recurring conceptual error: treating a syntax error -- code that stops the program from running at all -- as if it were a logic error. A program that cannot run produces no behaviour to describe, which is exactly what this prompt is asking for.
Written Response 2(c) -- the hardest point overall: the two most common misses are explaining what the whole program does, or what the feature does for the user, instead of specifically why building that functionality as a procedure makes the code easier to maintain -- and confusing procedural abstraction with data abstraction by describing the benefit of the list rather than the benefit of the procedure itself.
6. Written Response Day: What the 60 Minutes Actually Looks Like
The written-response section runs immediately after the multiple-choice section, inside the same Bluebook sitting -- there is no separate appointment and no option to come back to it later. Students get 60 minutes to answer all four prompts (Written Response 1, 2(a), 2(b), and 2(c)), and every response is automatically submitted the moment the section timer ends, whether or not the student has finished.
Detail | What to know |
Materials allowed | Only the student’s own Personalized Project Reference and the College Board AP CSP reference sheet -- no notes, no code editor, no outside material |
Time available | 60 minutes total for four prompts, immediately after the MCQ section |
Can the PPR be revised now? | No -- it is exactly what was submitted as final by April 30. Anything unclear, uncommented improperly, or missing was locked in months earlier |
Submission | Automatic at the end of the section; there is no manual "submit" step and no re-entry once time expires |
Because there is no partial credit within a row and no way to revise the PPR at this stage, the highest-value preparation is rehearsal: writing full responses to realistic prompts against a printed or saved PPR, under a timer, before exam day. A rough pacing guide -- roughly 10 minutes for Written Response 1 and 15–17 minutes for each of 2(a), 2(b), and 2(c) -- leaves a few minutes of buffer, but the right split depends on which prompt type a student’s practice has shown to be slowest.
Need a structured plan instead of going it alone? EduShaale’s 1-on-1 AP Computer Science coaching builds the exact written-response rehearsal system in this guide around a student’s own program and timeline -- not a generic template. |
7. Common Mistakes and Myths
Myth 1: "If my program works, I’ll get full credit on the Create Performance Task."
Reality: A working program secures 2 of the 6 rubric points -- the video and program requirements rows, worth 10% of the AP score. The other 4 points, worth 20%, are earned entirely through the 60-minute written response, and that is precisely where the national data in Section 5 shows scores collapsing.
What to do instead: Treat written-response practice as equal in priority to finishing the code, not as an afterthought for the final week before the deadline.
Myth 2: "When a prompt asks about one procedure or one list, I should describe how my whole program works."
Reality: Chief Reader commentary specifically flags this as a common way to lose the Written Response 2(c) point: describing the entire program’s functionality, or explaining a feature’s benefit to the user, instead of the narrower question actually asked -- why building this one piece of functionality as a procedure makes the code easier to maintain.
What to do instead: Before writing, reread exactly which procedure or list segment the prompt references in the PPR, and keep the answer scoped to that segment only.
Myth 3: "A syntax error counts as a logic error for the testing question."
Reality: It does not, and this is one of the most specific errors the 2025 Chief Reader Report calls out by name. A syntax error stops the program from running before it produces any behaviour at all, so there is nothing to describe changing. Written Response 2(b) is asking about a modification that changes what the program does while it runs -- not one that prevents it from running.
What to do instead: Pick a modification that alters a value, a condition, or a calculation the program still executes, and describe the different output or behaviour that results.
Myth 4: "A more elaborate program with more features will score higher."
Reality: The rubric does not reward feature count. It rewards a procedure with a parameter that genuinely affects the outcome, a list that is genuinely read from as well as written to, and a student who can explain both fluently under time pressure months later. A program too complex for its own author to explain clearly in a few sentences works against the written-response score, not for it.
What to do instead: Favour a program whose required elements are simple enough to explain from memory, and rehearse explaining them before the deadline, not just building them.
Myth 5: "I can keep refining my code and my Personalized Project Reference right up until April 30."
Reality: That is true of the deadline, but not of the practice window. Since the PPR is the only reference material available on exam day, whatever is submitted as final is what a student is working from months later, cold. Extra polish added the night before the deadline is never rehearsed against real written-response prompts.
What to do instead: Aim to have the PPR finalised with real weeks to spare, specifically so at least two or three timed practice writing sessions can happen against the actual, final document.
8. Designing a Program That Survives the Rubric
The program a student chooses to build has a direct effect on how easy the written response is to write later. A design decision that seems minor while coding in October can determine whether a rubric point is easy or nearly impossible to earn in May.
Give the parameter a job it visibly does: the clearest way to satisfy the rubric’s parameter expectation is to change the parameter’s value and confirm the output changes. If it does not, the parameter is decorative and hard to defend in Written Response 2(a).
Make the list earn its place: a list that is only ever appended to and never read from, filtered, searched, or iterated will not satisfy the "use of the list" requirement in row 2, and will make Written Response 2(c) -- already the hardest point nationally -- much harder to answer convincingly.
Write a real procedure, not an event handler: the 2025 Chief Reader Report specifically calls out event handlers used in place of a student-developed procedure as a common way to lose the Program Requirements point, especially in block-based languages. A procedure the student explicitly defines and explicitly calls is the safer structure.
Choose the two PPR segments before finishing the whole program: deciding early which specific procedure and which specific list will appear in the Personalized Project Reference means those segments can be built cleanly and deliberately, rather than picked under deadline pressure from whatever code happens to exist.
Keep the procedure’s job narrow enough to explain in three sentences: Written Response 2(c) asks why implementing this functionality as a procedure makes the program easier to maintain. A procedure with one clear responsibility is far easier to defend than one that handles several unrelated tasks at once.
Draft written responses while coding, not after: trying to explain a segment of code out loud while still writing it is the fastest way to discover that a list is not really being used, or that a procedure does not really need its parameter -- problems that are cheap to fix in October and expensive to discover in May.
9. AI Tools and the Create PT: What’s Allowed
This is one of the most frequently misunderstood parts of the current task, and the confusion runs in both directions -- some students assume AI tools are entirely banned, others assume anything goes as long as the final program works. Neither is accurate under the current policy.
The confirmed policy, per the 2025 Chief Reader Report Students are permitted to work with a partner, use starter code, and use AI tools while developing their program -- provided every instance is cited through comments in the program code component. AI assistance is treated the same way any other outside contribution is: it has to be disclosed in the code, not silently absorbed into a submission that implies the logic was entirely the student’s own unaided work. |
Where the citation goes -- and where it cannot go
This is the detail most students miss: AI or external-code citations belong in the full Program Code component (Component A), not in the Personalized Project Reference. As covered in Section 3, the PPR is not allowed to contain any comments or course content at all -- including citation comments -- on penalty of a zero for the entire task. A student who cites AI assistance correctly in their full code file, then copies an already-commented segment into the PPR without stripping the comment, can lose everything over a single line of attribution placed in the wrong document.
Situation | Allowed? | What’s required |
Using an AI tool to help write or debug part of the program | Yes | Cite the assistance in a comment within the full Program Code file (not the PPR) |
Using starter code or a library provided by a teacher or course | Yes | Attribute it clearly in the program code comments |
Working with a partner on the code itself | Yes | Both students may collaborate on code; video and written responses must still be each student’s own |
Comments or citations appearing inside the PPR screen captures | No | Results in a score of 0 for the entire Create Performance Task |
Using AI or outside help during the 60-minute written response | No | The exam-day writing is completed individually under standard AP exam conditions |
Beyond the specific AI rule, standard AP academic integrity policy still applies to the whole task: any code, video, or written material presented as original work that is not the student’s own can be flagged as plagiarism by a teacher, with supporting evidence, and can result in a cancelled score.
10. A Realistic Timeline for Your 9 Hours (and Beyond)
College Board requires at least nine hours of in-class time for the coding, filming, and documentation work -- but that figure covers the Create Performance Task submission only. It does not include the separate practice needed for the 60-minute written response, which happens on exam day using skills that have to be rehearsed well before then. The two need to be planned as connected but distinct blocks of time.
Inside the 9 required hours: building the submission
Hours | Focus | What to produce |
1–2 | Plan before coding | A program idea plus a short written plan naming exactly which procedure, parameter, and list will satisfy the six technical requirements |
3–6 | Core development | A working program that meets every Program Requirements element -- procedure, call, parameter, list, list use, selection, iteration -- none of them trivial |
7 | Record the video | A clear recording showing visible input, the program responding, and visible output |
8 | Build the Personalized Project Reference | Four legible, comment-free screen captures: the procedure definition, the call, the list being stored to, and the list being used |
9 | Final review and submission | A last check for comments or course content anywhere in the PPR, then Submit Final with the originality attestation on all three components |
Outside the 9 hours: rehearsing the written response
This is the work the national data in Section 5 shows most students skip. Once the PPR is finalised -- ideally with real time to spare before April 30 -- it becomes the exact document to practise against.
Weeks 1–2 after finalising the PPR: read the official AP Computer Science Principles Course and Exam Description’s sample prompts and scoring guidelines, and write one untimed response to each of the four prompt types against your own PPR.
Weeks 3–4: repeat the same four prompts under a real 60-minute timer, split roughly 10 minutes for Written Response 1 and 15–17 minutes each for 2(a), 2(b), and 2(c).
Final 2 weeks before the exam: self-score practice responses against the official scoring guidelines from Section 4, focusing specifically on the two hardest rubric rows -- 2(a) and 2(c) -- since that is where the national mean scores are lowest.
11. The Create PT vs. Other AP Assessments
Students choosing between AP courses, or trying to understand why CSP prep feels different from every other AP exam they are taking, benefit from seeing the structural differences side by side.
Dimension | AP CSP | Typical FRQ-based AP | AP Computer Science A |
Non-MC component | Through-course Create PT + exam-day written response | Free-response questions, written entirely on exam day | Four free-response questions, written entirely on exam day |
When the work happens | Months before the exam (code, video, PPR) plus 60 minutes on exam day | Entirely within the timed exam session | Entirely within the timed exam session |
Self-study possible? | No -- requires enrolment in a formal AP course section | Yes, widely self-studied | Yes, widely self-studied |
Weight of the non-MC component | 30% of the total score | Commonly 40–50%, varies by subject | Around 40% of the total score |
What’s in front of the student on the written portion | A self-authored Personalized Project Reference only | A College Board-provided reference or formula sheet, where applicable | The College Board Java Quick Reference |
The practical implication is that AP CSP cannot be crammed the way a purely exam-day AP can. A student who plans to self-study or catch up quickly for most AP exams has real options for compressing the timeline; a student in the same position for CSP is blocked by the course-enrolment requirement and the months-long nature of the Create Performance Task itself. For students weighing AP Computer Science A instead -- a subject with no performance task and where self-study is genuinely viable -- EduShaale has covered that comparison in detail in a dedicated guide on self-studying AP Computer Science A. Students choosing between CSP and the newer AP Cybersecurity course, which tests security concepts through multiple-choice and free-response questions without a project component, may also find EduShaale’s complete AP Cybersecurity guide useful for weighing the two.
12. AP CSP Score Distribution: What the 30% Swing Really Means
The final AP score is a composite: the 70-question multiple-choice section contributes up to 70 raw points (one per correct answer, no penalty for guessing), and the six Create Performance Task rubric rows each convert to 5 composite points, contributing up to 30. College Board does not publish the exact composite-to-AP-score cutoffs each year -- they are recalibrated after every administration -- so this guide will not invent specific thresholds. What is fixed and official is the underlying structure: 100 total composite points, split 70/30 between the multiple-choice section and the Create Performance Task.
AP score | Students (2025) | % of test-takers |
5 -- Extremely Well Qualified | 18,847 | 10.7% |
4 -- Well Qualified | 35,015 | 19.9% |
3 -- Qualified | 54,777 | 31.1% |
2 -- Possibly Qualified | 37,604 | 21.4% |
1 -- No Recommendation | 29,692 | 16.9% |
Source: College Board, AP Computer Science Principles Student Score Distributions, May 2025 (175,935 total test-takers; mean score 2.86; 61.7% scored 3 or higher).
Why this section is where preparation time is best spent Because the video and Program Requirements rows are already earned by roughly 85–95% of students nationally, there is little score left to gain there for a student who already has a working program. The realistic swing available to most students sits almost entirely in the three lower-scoring written-response rows -- 2(a), 2(b), and 2(c) -- worth 15 of the AP score’s 100 composite points combined. Closing even half the gap between the national average on those three rows and a full score is a larger, more achievable score improvement than anything left to gain from further polishing the program itself. |
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
13. Frequently Asked Questions
Q: What percentage of my AP CSP score is the Create Performance Task?
A: The Create Performance Task and its written response together make up 30% of the final AP Computer Science Principles score. That splits into 10% from the code, video, and Program Requirements you submit through the AP Digital Portfolio, and 20% from the four written-response prompts answered on exam day. The remaining 70% comes from the 70-question multiple-choice section.
Q: Is the video still required, or was it removed in the 2024 redesign?
A: The video is still required and is still scored as its own rubric row. The 2024 redesign removed the written response from the through-course portfolio submission and moved it to a 60-minute session on exam day -- it did not change the video or program code requirements, which remain part of the three-component Digital Portfolio submission.
Q: Can I resubmit or revise my Create Performance Task if I’m unhappy with it?
A: No. Once a component is submitted as final in the AP Digital Portfolio, it cannot be revised, and only components submitted as final by the April 30 deadline are sent for scoring. This makes the final review pass before submission -- especially checking the Personalized Project Reference for stray comments -- worth doing carefully rather than quickly.
Q: Can I work with a partner on the Create Performance Task?
A: You can collaborate with a partner while developing the program code itself. The video, the Personalized Project Reference, and the written responses on exam day must each be your own individual work -- College Board directions specifically describe the video as individually created and the PPR as student-authored.
Q: What programming language should I use for the Create Performance Task?
A: Any language is acceptable, including text-based languages like Python and JavaScript and block-based environments like Scratch and Snap!. Most students use whatever language their AP CSP course was taught in, since that keeps the required elements -- procedures, parameters, lists, selection, and iteration -- familiar to explain in the written response.
Q: Can I use AI tools like ChatGPT on the Create Performance Task?
A: Yes, during development -- College Board’s current policy allows AI assistance, partner collaboration, and starter code, provided each is cited in a comment within the full program code file. That citation cannot appear in the Personalized Project Reference, which is not allowed to contain any comments at all. The 60-minute written response on exam day must be completed without AI or outside assistance, under standard AP exam conditions.
Q: What happens if my Personalized Project Reference includes comments or course content?
A: College Board’s student directions state that including comments or course content anywhere in the Personalized Project Reference results in a score of zero for the entire Create Performance Task -- not a deduction on one row. This applies even to well-intentioned comments, such as citing an AI tool or a source, which belong in the full program code file instead.
Q: Who actually scores the Create Performance Task?
A: Trained AP Readers score every component at College Board’s annual AP Reading, using the official published scoring guidelines. In 2025, 679 Readers scored 175,935 Create Performance Tasks. Each of the six rubric rows is scored independently against fixed criteria, with no partial credit within a row.
Q: Can I self-study for AP Computer Science Principles?
A: Not in the way most other AP subjects allow. AP CSP is one of only three AP courses -- along with AP Seminar and AP Research -- that require enrolment in a formal AP course section specifically because of the performance-task component, since the Create Performance Task has to be completed through a school’s AP Digital Portfolio with teacher-provided class time. A student cannot register for CSP as an exam-only, self-studied subject the way they could for AP Computer Science A or AP Chemistry.
Q: What is the difference between AP CSP and AP Computer Science A?
A: AP Computer Science Principles is a broad introduction to computing concepts -- programming, data, the internet, and the impact of computing on society -- assessed through multiple-choice questions and the Create Performance Task described in this guide. AP Computer Science A is a deeper, Java-specific programming course assessed through multiple-choice questions and four free-response questions, with no through-course project component and no formal-enrolment requirement, which is why it can be self-studied more readily.
Q: When is the Create Performance Task due, and when is the 2026 AP CSP exam?
A: For the 2025–26 school year, all three Create Performance Task components are due in the AP Digital Portfolio by 11:59 p.m. ET on April 30, 2026. The AP Computer Science Principles end-of-course exam, which includes the multiple-choice section and the 60-minute written response, is scheduled for May 14, 2026. Always confirm current-year dates against AP Central, since scheduling is set fresh each year.
Q: Do colleges give credit for AP Computer Science Principles?
A: Many colleges grant credit or placement for a qualifying score, though policies vary significantly by institution -- some award general elective credit, others award introductory computer science credit, and some competitive computer science programmes set a higher score threshold than they do for other AP subjects. Because CSP does not require the language-specific programming fluency AP Computer Science A does, credit treatment can differ between the two exams even at the same university. Always verify current policy using College Board’s official AP Credit Policy Search tool before assuming a specific outcome.
Q: What happens if I don’t finish all three Create Performance Task components by the deadline?
A: Only components submitted as final by the deadline are sent for scoring, and each is scored independently -- but the Personalized Project Reference matters most on exam day specifically, since it is the only reference material available during the 60-minute written response. A student who submits a program and video but not a finalised PPR will sit that portion of the exam without any reference document at all. A student who completes no components can still sit the end-of-course exam and receive a score, but forfeits the full 30% tied to the Create Performance Task.
Q: How many of the six rubric points do I need to feel confident about a strong score?
A: College Board does not publish exact composite-to-AP-score cutoffs, so this guide will not invent one. What the 2025 data does show is that the national average was about 4.04 of the 6 points, driven down mainly by the two hardest rows -- Written Response 2(a) and 2(c), each earned by fewer than half of students. Earning most or all six points, particularly those two, puts a student meaningfully ahead of the average scorer on this portion of the exam.
14. EduShaale -- Expert AP Computer Science Coaching
EduShaale provides 1-on-1 AP Computer Science coaching built around the exact gap this guide documents: the distance between a working program and a written response that actually earns its points under a 60-minute clock.
Create PT Design Coaching: sessions that plan the program’s required procedure, parameter, and list before a single line of code is written, so the final submission is easy to defend later -- not assembled backward from whatever code exists near the deadline.
Written Response Rehearsal: timed practice against a student’s own finalised Personalized Project Reference, targeting the exact three rubric rows -- 2(a), 2(b), and 2(c) -- where the 2025 national data shows the most points lost.
PPR Compliance Review: a dedicated check for stray comments or course content before submission, closing off the single mistake that can zero out an otherwise strong Create Performance Task.
9-Hour-and-Beyond Planning: a session-by-session calendar that covers the required in-class development time and the separate written-response rehearsal weeks most students skip entirely.
Free AP Computer Science Diagnostic Assessment -- testprep.edushaale.com
Free Consultation -- Create Performance Task Timeline 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 students who earn the most points on the Create Performance Task are rarely the ones with the most ambitious program. They are the ones who can explain a simple, deliberately-scoped procedure and list fluently, from memory, sixty minutes into a Saturday morning exam. Building the program is necessary but not sufficient -- rehearsing the explanation is what the 2025 national data shows actually separates a strong score from an average one. |
15. 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.
Scoring and score-distribution figures are sourced from official College Board publications for the 2025 exam administration, the most recent complete data available at the time of writing. Deadlines and exam dates reflect the 2025–26 cycle; all figures should be verified against apcentral.collegeboard.org and apstudents.collegeboard.org before relying on them for exam-day planning, since College Board updates dates and guidance annually.
This guide is for educational purposes only and does not constitute legal, financial, or college admissions advice.
Comments