The AP CSP exam tests both your conceptual understanding and your ability to communicate about computing through multiple-choice questions and a three-part free-response section. Knowing exactly what each section asks and how responses are scored is the fastest way to stop losing points you already know how to earn.
Fiveable's AP Computer Science Principles Exam Skills review covers 5 topics, with guided practice questions for the unit.
Use this guide to understand the exam format, FRQ scoring expectations, and the specific moves that separate a 3 from a 4 or 5.
AP CSP is structured differently from most AP exams. The free-response section is not a traditional essay or math problem set. It includes a video component, a program demonstration component, and a written response that requires you to describe and justify specific features of your code. Each part is scored independently against a rubric, so a weak video does not sink your written response score.
Section I is 70 MCQs in 120 minutes. Section II has three FRQ components: Video, Program Requirements, and Written Response 1. Each component is scored on its own rubric criteria, and you must address every required element explicitly in your response.
70 questions in 120 minutes gives you about 1 minute 42 seconds per question. The section includes single-select questions and a 5-question reading-passage set. Questions test computing concepts, algorithms, data, the internet, and impacts of computing. Eliminate clearly wrong answers and flag time-consuming questions to return to.
The free-response section has three components: a Video task where you submit a short video of your program running, a Program Requirements task where you demonstrate your program meets specific functional criteria, and Written Response 1 where you describe and explain your code in writing. Each component is scored separately.
Written Response 1 is scored on a rubric with specific required elements. You must describe what your program does, explain how a specific algorithm works, and identify a list or collection and explain how it manages complexity. Vague or general answers do not earn points. You must reference your actual code explicitly.
Past students who scored 4s and 5s consistently report that the biggest mistake is writing generally about what a program does instead of pointing directly to specific lines, functions, or variables. Every written response point on the rubric requires you to connect your explanation to concrete evidence in your own code. Longer answers that stay vague earn fewer points than shorter answers that are precise.
Read the FRQ rubric rows carefully before drafting any response. Each row is scored independently. Knowing exactly what each row asks prevents you from writing a long answer that misses the actual requirement.
The feature you demonstrate in your video should be the same feature you explain in Written Response 1. Scoring readers evaluate both, and a mismatch between them is one of the most common reasons students lose points they could have earned.
Every written response point requires you to connect your explanation to your actual program. Use the names of your variables, functions, and lists exactly as they appear in your code. General descriptions of what a program does are not enough.
Do not spend more than 2 minutes on any single MCQ during your first pass. Flag questions that require long code traces or that you are uncertain about, answer every question before time is called, and return to flagged questions with remaining time.
Fiveable's AP score calculator can help you estimate what raw score you need to reach your target AP score. Use it to decide how many MCQs you can afford to miss and how much the FRQ rubric points matter to your overall goal.
With 70 questions in 120 minutes, pacing is a real constraint. The reading-passage set of 5 questions shares a common scenario, so reading it carefully once pays off across all five questions. For algorithm and code-trace questions, work through the logic step by step rather than trying to predict the answer from the structure of the code.
Can you trace through a nested loop or conditional in AP pseudocode and correctly identify the final output without second-guessing yourself?
| Question Type | What It Tests | Key Move |
|---|---|---|
| Single-select MCQ | Concepts, algorithms, data, impacts | Eliminate, then confirm |
| Reading-passage set | Applied reasoning on a shared scenario | Read once, answer all five |
| Code-trace MCQ | Following pseudocode logic step by step | Write out variable states manually |
The video must show your program running and producing output. It cannot include any narration or distinguishing information that would identify you. The video is short, typically under 1 minute, and must clearly show the feature you will describe in your written response. Record it after your program is fully functional, not as a work-in-progress.
Does your video clearly show a specific program feature producing visible output, with no narration or identifying information?
| Requirement | Meets Standard | Does Not Meet Standard |
|---|---|---|
| Output shown | Program runs and produces visible output on screen | Program is shown in editor only, no output visible |
| Narration | Silent video with no voiceover | Student explains what is happening verbally |
| Feature match | Video shows the same feature described in written response | Video shows a different part of the program than what is written about |
Written Response 1 has specific rubric rows, and each row requires a distinct type of explanation. You must describe the overall purpose of your program, explain how a specific algorithm you wrote works including sequencing, selection, or iteration, and describe a list or collection and explain how it manages complexity. Each explanation must reference your actual code, not a hypothetical.
Can you point to a specific list in your code and write two sentences explaining how it manages complexity that would satisfy the rubric?
| Rubric Element | Strong Response | Weak Response |
|---|---|---|
| Program purpose | States what the program does for the user in concrete terms | Says 'my program uses variables and loops' |
| Algorithm | Names a specific algorithm the student wrote and traces its logic | Describes a built-in sort or search function |
| List use | Names the list, its contents, and explains the complexity benefit | Says 'I used a list to store data' |
The rubric for the algorithm row requires you to explain the logic of a specific algorithm you wrote, including how sequencing, selection, or iteration operates within it. Saying 'my program sorts a list and displays the result' does not earn this point. You must explain the steps of the algorithm itself.
Pointing to a built-in sort, search, or filter function and calling it your algorithm does not satisfy the rubric. The algorithm must be one you wrote. If your program relies heavily on built-in functions, identify a conditional or loop you authored and explain that instead.
Many students correctly identify a list and describe what it stores but stop there. The rubric requires you to explain how using the list manages complexity, meaning you need to argue why the list makes your program simpler or more scalable than not using it would be.
If your video shows one feature of your program but your written response describes a different feature, scoring readers will notice. Choose one specific feature, demonstrate it in the video, and write about that same feature in your response.
Code-trace questions that require stepping through nested loops or conditionals can take 3 to 5 minutes if you try to hold everything in your head. Write out variable states on scratch paper and move on if a question is taking too long. Flag it and return rather than letting it consume time from easier questions.
Each row of the Written Response 1 rubric is evaluated on its own. A weak answer on the program purpose row does not affect your score on the algorithm row. This means you can still earn most of the FRQ points even if one section of your response is incomplete, as long as the other sections are precise and specific.
The 5-question reading-passage set in Section I is built around a shared computing scenario. Students who read the passage carefully once and then answer all five questions together tend to perform better on this set than students who skim and re-read for each question. Treat it as a mini-document analysis, not five separate questions.
Past students who scored 4s and 5s consistently identify the same pattern: responses that name specific variables, functions, and lists from their actual code earn rubric points, while responses that describe what a program does in general terms do not. Every sentence in your written response should connect to something a reader could find in your code.
70 questions in 120 minutes. I have a plan for the reading-passage set and for code-trace questions that take longer than average.
I know the rubric requires a program purpose statement, an algorithm explanation with sequencing, selection, and iteration, and a list or collection explanation that addresses managing complexity.
My video is silent, shows the program running and producing output, and demonstrates the same feature I describe in my written response.
I use the exact names of my variables, functions, and lists from my program. I do not describe hypothetical code or built-in functions as my own algorithm.
I can name my list, describe what it stores, and write a clear explanation of why using it makes my program less complex than an alternative approach would be.
The FRQ tips guide on Fiveable includes advice from past students organized by component. I have read the sections relevant to my weakest rubric areas.
Read the official AP CSP FRQ rubric and identify every row in Written Response 1. For each row, write one example response using your own program. Check whether your example would earn the point based on the rubric language, not your own judgment about whether it sounds good.
Set a timer for 1 minute 42 seconds per question and work through algorithm and pseudocode questions. If you cannot finish a code trace in that time, practice writing out variable states faster rather than trying to do it mentally.
Write a full draft of Written Response 1 and check it against each rubric row. Ask a classmate or teacher to read it and identify which rows they think you earned. Revise based on any rows that are unclear or missing. Read the FRQ tips guide on Fiveable for specific language strategies from past high-scoring students.
Record your video and watch it back while reading your written response. Confirm that the feature shown in the video matches the feature described in your response. Check that the video shows visible output and contains no narration or identifying information.
Use Fiveable's AP score calculator to estimate your current score based on your expected MCQ performance and FRQ rubric points. Identify the two or three rubric rows or MCQ topic areas where you are least confident and spend your remaining study time there rather than reviewing material you already know well.
Open the individual guides for Exam Skills when you want a closer review of one topic.
Use AP-style practice after you review the notes so you can check what you understand.
Practice free-response reasoning and compare your answer with scoring guidance.
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Estimate your broader AP score goal after you review the course and exam format.
Print the cheatsheet bundle ($14) for this subject. Yours to keep, no subscription needed.
get printablesThe AP CSP exam has two sections. Section I is 70 multiple-choice questions in 120 minutes, worth 70% of your score. Section II includes the Create performance task (submitted to the AP Digital Portfolio) and two written-response questions with four prompts completed on exam day, worth 30% combined.
The Create task is submitted through the AP Digital Portfolio before exam day. It is scored against a rubric that evaluates your program's functionality, algorithm development, and written responses explaining your process. Reviewing the official scoring guidelines before you submit helps you understand exactly what graders look for.
The exam draws from five main areas: creative development, data representation and analysis, algorithms and programming, computer systems and networks, and computing's impact on society. Multiple-choice questions test conceptual understanding and code reading, while written-response prompts focus on computing innovations and their effects.
For the 70-question multiple-choice section, pace yourself to about 100 seconds per question. Trace through code snippets on scratch paper rather than in your head, eliminate clearly wrong choices first, and flag difficult questions to revisit. Students who scored 4s and 5s consistently recommend practicing with full-length timed sets before exam day.
The two written-response questions on exam day include four prompts covering computing innovations and program design. Practice outlining your answers before writing, use specific examples, and check your response against the scoring criteria. Reading exemplar responses from past exams helps you understand what a complete, high-scoring answer looks like.
The College Board's AP Central site offers released exam questions, scoring guidelines, and Create task exemplars. Fiveable's AP CSP pages cover every unit with guides and tips from students who earned 4s and 5s. Combining official materials with targeted unit review gives you the broadest preparation across all tested concepts.