AP Computer Science Principles is the only AP exam where the bulk of the grade comes from artefacts a student produces months in advance. The Create Performance Task alone is worth 30 percent of the total AP score, and it is graded against a six-row rubric that most students meet for the first time when they open the digital portfolio portal in April. The two-hour end-of-course MCQ is the smaller battle. The Create task is the campaign. Treat it that way from day one of preparation, and the rest of the year stops feeling like a scramble.
This article is written for students who are starting, restarting, or auditing an AP Computer Science Principles preparation plan. The focus is the Create Performance Task: the program, the written responses, the video, the six rubric rows, the most common 1-point and 0-point deductions, and the study habits that move a candidate from a 5 to a 6. Every other component of the exam is named only insofar as it interacts with Create — the MCQ weighting, the reference sheet, and the impact of the task score on overall AP scoring. If you are building a preparation plan from scratch, this is the strand to anchor first.
What the AP Computer Science Principles Create Performance Task actually asks of you
The Create task has three deliverable parts. Part 1 is a working program of your own design, written in an approved language, that contains a list, a procedure with a parameter, an algorithm, repetition, selection, and a call to that procedure. The program must run, must be original to you, and must be saved in the College Board digital portfolio as a single file or as a project of linked files. Part 2 is a PDF containing your responses to four written prompts about that program. Part 3 is a video of no more than one minute in which the program runs while you point out the segments that satisfy the rubric rows. That is the whole task. No partner, no extension questions, no surprise prompts. The shape is fixed every year.
Most candidates lose sight of three structural facts. First, the program does not have to be ambitious. A correct 80-line program that cleanly demonstrates every required element will outscore a sprawling 800-line game that fails to document one of them. Second, the written responses are scored by humans, not machines, and a 200-word response that clearly states the list, names the procedure's parameter, identifies a segment that runs the algorithm, and points to selection is worth as much as a 600-word response that buries the same information in a story about inspiration. Third, the video is the only rubric row where a candidate can lose points that the written response would have earned. The video is not optional rehearsal. It is the second of two chances to demonstrate the same evidence.
For most candidates, the practical upshot is simple. Pick a program idea in the first two weeks of class, build it in stages, and leave at least four weeks before the submission deadline for documentation. In my experience, students who wait until the deadline week to start the written responses lose the single largest point source in the task: the segment-by-segment mapping between their code and the rubric rows. Build the program first, then write the documentation against the rubric, then re-record the video against the same rubric. The order is everything.
The six rubric rows and how each one is decided
The Create task is scored out of six points, one per row, and the rows are designed so that each one is independently satisfiable. You can score 6 out of 6 without ever having written a single line of elegant code, because the rubric rewards completeness of evidence, not aesthetic quality. The rows fall into three pairs. Rows 1 and 2 cover the program. Rows 3 and 4 cover the written responses. Rows 5 and 6 cover the video.
Row 1: program design and development
Row 1 awards the point if your program video shows the program running. The candidate must be visible, the program must be visible, and the program must be observed to do something — output text, draw a shape, respond to input. A video that shows only code, with the program never running, scores 0 on Row 1. A video in which the program is run but the candidate is not visible also scores 0. A video in which the program crashes and never produces output scores 0. The point is binary, the criteria are literal, and the most common loss is technical: a black screen, an editor that hides the console, a window minimised under the recording software, a paused process. Test the recording setup twice with the exact program you intend to submit before the deadline week.
Row 2: algorithm implementation and a list
Row 2 awards the point if the written response identifies an algorithm in the program, names a segment of code that implements it, and explains in plain English what the algorithm does. The segment must contain sequencing, selection, or repetition in some non-trivial combination. A list — a one-dimensional collection of items — must be used in the program and referenced in the response. The list does not have to contain the algorithm, but the program must contain a list. A common failure is to define the list inside a function that the response never names, or to use a built-in sort without ever showing the comparison step in the response. The simplest way to guarantee the point: write a function that loops through a list and prints each item, then reference that function by name in the response. It is unglamorous, but it locks Row 2.
Rows 3 and 4: written response on the procedure and the algorithm
Row 3 covers the procedure. The response must name a procedure, name a parameter of that procedure, describe what the parameter affects, and describe what the procedure returns or changes when called. Row 4 covers the algorithm in deeper terms. The response must describe the algorithm's purpose in the program, explain how the named segment implements it, and identify a different segment that contributes to the same function. Together these two rows test whether the candidate can describe their own code at two levels of abstraction. The first describes one named unit. The second describes the program's behaviour as a system. Students lose both rows most often by writing responses that read like a tutorial to a stranger, instead of a structural description to a reader who has the code in front of them. Be specific. Name the function. Quote the line. State the return value.
Rows 5 and 6: video coverage of code and functionality
Row 5 awards the point if the video shows the program's code and the candidate is narrating it. The narration must point to specific lines or blocks that contain the procedure and the algorithm. Row 6 awards the point if the video shows the program running and producing output for the specific input the candidate is describing. Together they require a one-minute video that interleaves three artefacts: a screen of code, a screen of running program, and a candidate who is speaking. The pacing is tight. A 60-second budget means roughly 20 seconds of code narration, 20 seconds of code talk, 20 seconds of running output, with at least one transition between them. Pre-rehearse the script once. The first take is rarely the take you submit.
Common pitfalls and how to avoid them on the Create task
The Create task is graded in a small window, and the same handful of mistakes account for the majority of deductions. None of them are about programming skill. They are about the difference between writing a program and documenting it. If you are reading this in the middle of a preparation cycle, the list below is the place to start.
- Submitting code that is not your own work. The portfolio is checked for plagiarism against a database of previously submitted work, and against online sources. Lift nothing. Translate ideas, do not copy snippets. When in doubt, write the segment from memory in a fresh file.
- Hiding the program running inside an IDE window that the recorder cannot capture. Run the program in a separate window, with the console or canvas visible, before you record. Confirm the screen is captured by playing the video back once.
- Writing a procedure that never uses its parameter. This is a Row 3 failure that is invisible until grading. A procedure that ignores its parameter and returns a constant will be marked 0 because the response cannot describe what the parameter affects.
- Storing the list in a way the response cannot name. If the list is created by reading a file or a network source, the response must still name the variable and state what is in it. Hidden lists lose Row 2.
- Recording a video over 60 seconds. The video is capped. A long video is not a better video. The grading rubric ends at one minute. Anything past that is invisible to the scorer.
- Submitting written responses that exceed the response length limits. Each of the four written prompts has a recommended word or sentence budget. Going over budget is not a deduction by itself, but it signals that the candidate has not been editing, and it costs the grader time. Stay within the suggested range.
- Designing a program that requires a partner or external service to run. The portfolio cannot include a partner's portion, and the program must run on the grader's machine. Local files only.
How the Create task score lifts the rest of the AP CSP exam
The AP Computer Science Principles exam has two components, weighted equally in the overall score: the Create Performance Task and the end-of-course MCQ. Each contributes 50 percent of the raw points, although Create is reported as a 0-to-6 rubric score and the MCQ is reported on its own scale. The two are combined by College Board into a single AP score on the 1 to 5 scale. That means a strong Create performance can carry a weaker MCQ day, and a poor Create score can flatten an otherwise strong MCQ performance.
For most students the practical planning implication is this. A 6 on Create is worth the same as a high band on the MCQ, but a 6 on Create is also far more controllable. The MCQ is 70 questions in 2 hours, drawn from five Big Ideas, and the reference sheet is a fixed set of allowed vocabulary. The Create task is open-ended but bounded. The MCQ is graded by computer; the Create task is graded against a published rubric. You can study for the MCQ in a way that prepares you for 60 to 70 percent of the questions. You can prepare for Create in a way that earns every point of the rubric. The expected return on additional study time is higher on Create. Build the schedule that reflects that.
The MCQ side: how Create habits feed into the multiple-choice section
The two-hour MCQ is graded by computer, and the reference sheet lists every construct the test writers can use. The reference sheet includes list, list indexing, append, procedure, parameter, return, if, while, for, and, or, not, mod, concat, length. Reading questions on the MCQ are essentially asking whether you can recognise those constructs when they are described in plain English. The habits you build while doing Create are the same habits that score MCQ points.
Three routines from Create translate directly to the MCQ. First, naming things clearly. A variable called user_score in a Create program is a variable called user_score on the MCQ. The ability to read a name and infer the role of a variable is the single most important MCQ skill. Second, describing parameters accurately. The Create Row 3 response asks you to describe what a parameter affects. The MCQ asks you to predict what a procedure will do when called with a given argument. The mental process is the same. Third, tracing through code line by line. A Create video is, in effect, a trace. The MCQ questions on algorithm output are traces. Practise tracing on paper, with a pencil, line by line, before picking an answer. For most candidates, tracing beats intuition in the long run.
Scoring the whole AP CSP exam: a worked example
Suppose a candidate, A, finishes the year with a Create rubric score of 5 out of 6 and an MCQ raw score that maps to 38 out of 40 on the MCQ scale. The weighted combined score will be in the high band of a 5, often above the threshold for a 5 on the final AP grade. A different candidate, B, scores 3 out of 6 on Create and 40 out of 40 on the MCQ. Candidate B's combined score will be lower, sometimes sitting in the high 4 range, because the 50 percent weighting of Create pulls the average down. The point is not that one candidate is smarter. The point is that the 50/50 weighting means a half-finished Create task is the single most expensive mistake on the exam.
Comparing the two AP Computer Science Principles exam components
The table below summarises the structural differences between the two AP CSP exam components. Use it as a study-planning tool, not as a substitute for the official course and exam description.
| Dimension | Create Performance Task | End-of-course MCQ |
|---|---|---|
| Weight in AP score | 50 percent | 50 percent |
| Format | Program plus written responses plus video | 70 multiple-choice questions |
| Time | Administered in class over weeks | 2 hours |
| Scored by | Human graders against a 6-row rubric | Computer against a fixed key |
| Open to interpretation | Limited — rubric is explicit | None — single correct answer |
| Preparation horizon | Months | Weeks |
| Highest expected yield per study hour | Routine-based documentation practice | Reference-sheet vocabulary drills |
A preparation plan that puts Create first
Most AP CSP preparation plans treat Create as a project that happens at the end of the course, with a long quiet stretch of Big Idea reading in the middle. That is the inverse of what the weighting deserves. A more effective plan front-loads the project work and uses the program's needs to drive reading. The candidate learns about lists because the program needs a list. The candidate learns about parameters because the procedure needs a parameter. The reading is anchored, the project is anchored, and the two reinforce each other.
Concretely, the first six weeks of a strong AP CSP preparation plan look like this. Week one: choose a program idea and sketch the data the program will manipulate. Week two: build the list and a procedure that operates on it. Week three: add the algorithm and at least one piece of selection logic. Week four: introduce a parameter whose effect on the output is visible in the running program. Week five: draft the four written responses against the rubric, line by line. Week six: record a first video, watch it back, and write a 200-word self-critique. After week six, the project is essentially a 5. The remaining weeks of the course are spent polishing to a 6 and preparing for the MCQ by drilling the reference sheet vocabulary. In practice, candidates who follow this arc rarely score below a 5 on Create. Candidates who start the project in the final month often score 3 or 4.
What the rubric does not measure, and why that matters
The Create task rubric does not measure algorithmic elegance, code style, language choice, or use of advanced data structures. It does not penalise a candidate for using a turtle graphics library, a simple text output, or a single screen of pixels. It does not reward a candidate for using recursion, classes, or async patterns unless the rubric rows are also satisfied by simpler constructs. The rubric is intentionally narrow. A candidate who treats the rubric as the only specification of a good submission is a candidate who earns the most points for the least wasted effort.
This narrowness has a side effect worth naming. The most common reason a candidate loses a Create point is over-engineering. The candidate writes a class hierarchy where a procedure would have done. The candidate uses a library call where a hand-written loop would have been documented. The candidate imports a sorting routine from a standard library and cannot name the comparison step in the response. In each case, the candidate has built something more interesting than the rubric asked for and has scored lower than a simpler alternative would have. The fix is counter-intuitive but consistent. Read the rubric, satisfy the rubric, and stop. The remaining 90 percent of programming ambition can go into a side project, not the submission.
Tactical checklist for the final two weeks before submission
Two weeks before the Create task deadline, the work is no longer about the program. The work is about packaging. The following tactical checklist is what I run through with each candidate I coach at this stage, in the order that catches the most deductions earliest.
- Confirm the program runs on a clean machine, with no partner's files, no internet calls, and no missing assets. Reboot, open the file, and watch it run end to end.
- Open the written responses and confirm each one names the specific segment of code it claims to. Highlight the variable name, the procedure name, the algorithm name, and the selection logic. A response that cannot be highlighted is too vague.
- Re-record the video with a script that interleaves code narration and running output, with the candidate visible and audible throughout. Watch the video back at 0.5x speed to confirm the rubric rows are visibly demonstrated.
- Confirm the video is 60 seconds or less. Trim aggressively. A 58-second video that shows the work is better than a 70-second video that hides the work under transition screens.
- Open the portfolio portal and confirm the file types, the file names, and the order of the responses. A wrong file type is one of the few ways a candidate can lose all six points at the portal level.
Conclusion and next steps
The Create Performance Task is the single most controllable component of the AP Computer Science Principles exam, and a 6 out of 6 is realistic for any candidate who treats the rubric as the specification. The work is to choose a simple program early, build the required constructs into it deliberately, document them against the rubric rows, and rehearse the video until the one-minute budget is tight. After that, the MCQ side of the exam becomes a vocabulary drill on the reference sheet, anchored by the same habits. The two halves of the exam reinforce each other, and a strong Create performance carries weight the MCQ alone cannot. If you are at the start of a preparation cycle, the next concrete step is to sketch a program that contains a list, a procedure with a parameter, an algorithm, repetition, and selection — and to do it this week. TestPrep İstanbul's diagnostic work on the Create Performance Task is a natural starting point for candidates building a sharper preparation plan around that goal.