AP CS Principles Create Task: Step-by-Step Guide

The Create Performance Task is worth 30% of your AP CS Principles score, and unlike the multiple-choice exam, you complete it at home over several weeks before exam day. That's both an advantage and a trap. The advantage: you have time to do it well. The trap: many students don't understand what the rubric is actually looking for, and they lose points on work they spent hours completing.

This guide walks through every step of the Create Task, from choosing a program through writing your final responses, with specific examples of what earns points and what doesn't.

What You Submit

The Create Task has three deliverables:

1. Your program code, submitted as a PDF or through the College Board's approved submission platform.
2. A video (under 1 minute, no audio required) showing your program running and demonstrating its input, processing, and output.
3. Written responses to four prompts about your program's purpose, data abstraction, procedural abstraction, and testing.

The written responses are where most points are won or lost. Your program can be impressive, but if the responses don't hit the rubric criteria precisely, you won't earn those points.

The Rubric: 6 Points, 6 Requirements

The Create Task is scored on 6 rows, each worth 1 point. You earn the point for a row or you don't; there's no partial credit within a row. Here's what each row requires:

Read this table carefully. Many students lose points not because their program is weak, but because their written responses don't address these criteria precisely. A strong program with vague responses earns fewer points than a simple program with responses that hit every rubric row directly.

Step 1: Choose the Right Program

Your program doesn't need to be impressive or complex. It needs to satisfy the rubric. Many students make the mistake of building something elaborate, then struggling to explain it clearly in the written responses. A well-understood simple program almost always scores higher than a complex one you can only partially explain.

Your program must include all of the following

• A list that stores multiple related values and is accessed (not just created) somewhere in the program.
• A student-developed procedure (a function you wrote yourself, not a built-in function) with at least one parameter that actually affects what the procedure does.
• Inside that procedure: sequencing (statements that run in order), selection (an if/else), and iteration (a loop). All three must appear inside the same procedure.
• The procedure must be called at least twice with different arguments that produce different results.

Good program ideas

• A quiz app that stores questions and answers in a list, loops through them, checks answers with a conditional, and tracks a score.
• A simple grade calculator that stores scores in a list, filters by a threshold, and computes averages.
• A word frequency counter that reads a list of words and counts how often a given word appears.
• A to-do list manager that stores tasks, marks them complete, and filters by status.
• A simple game (number guessing, rock-paper-scissors) that keeps a list of results and computes statistics.

What to avoid

• Programs with no meaningful list. If the list is just decoration (you create it but never use the data stored in it to make a decision or produce output), Row 2 and Row 3 are at risk.
• Procedures whose parameter doesn't matter. If the procedure produces the same result regardless of what argument is passed, you won't earn Row 4. The parameter must actually change the behavior.
• Procedures missing sequencing, selection, or iteration. A procedure with only a loop and no conditional, for example, won't earn Row 5. All three elements must be present in the same procedure.
• Programs that are too simple to call twice with different results. If your procedure always prints "Hello" regardless of input, you can't satisfy Row 6.

Step 2: Build Your Program

Once you have a program idea that satisfies the checklist above, build it in whatever language your class uses. Most students use Python, JavaScript, or MIT App Inventor. The College Board accepts any language.

As you build, keep the rubric open. After you finish, go through each row and ask: "Does my program clearly satisfy this?" If the answer for any row is "I think so, maybe," that's a warning sign. Clarity matters. A grader reading your code and responses for the first time should be able to identify the list, the procedure, and all three algorithmic elements without hunting for them.

Mark your code segments before writing responses

The written responses ask you to include specific code segments. Before you start writing, identify exactly which segments you'll use for each row:

• Row 2a: a segment where the list is created or data is added to it.
• Row 2b: a segment where data from the list is accessed and used.
• Row 4a: the full definition of your student-developed procedure.
• Row 4b: a segment showing the procedure being called (at least once).

Make sure these segments are distinct and clearly show what the rubric requires. Don't use the same code segment for 2a and 2b; they need to show different things.

Step 3: Record Your Video

The video must be under 1 minute and show the program running. No narration is required, but the video must demonstrate:

• Input: something the user provides, or data the program receives from a source.
• Program functionality: the program doing something with that input.
• Output: something the program produces as a result.

The video is graded for Row 1 (Program Purpose and Function). Graders check that your program actually runs and that the input/processing/output are visible. Keep it simple: start the program, show some input, show the output. You don't need music, titles, or editing.

Common video mistakes:

• The video shows only the final output, not the input. Make sure the input is visible before you show the result.
• The video is too long. Edit it to stay under 60 seconds; graders will stop watching.
• The program crashes or shows an error during the video. Run through it once before recording to make sure everything works.

Step 4: Write Your Responses

This is where the most points are won or lost. Each response has a word limit; stay under it. Graders are not impressed by length; they're checking for specific content.

Response 3a: Program Purpose and Function

What you need to address:

• Describe the overall purpose of the program.
• Describe what the program does when it runs (its functionality).
• Describe the input and output of the program.

Purpose vs. function: this distinction costs more points than any other.

• Purpose is WHY the program exists: the problem it solves or the need it addresses. It answers the question "why would someone use this?"
• Function is WHAT it does: the specific processing it performs on inputs to produce outputs.

Example program: a quiz app that asks math questions and tracks the user's score.

Weak response (purpose = function, doesn't earn the point):
"The purpose of my program is to ask the user math questions and display their score."

Strong response (purpose and function clearly distinct):
"The purpose of my program is to help students practice mental math and track their improvement over multiple attempts. When the program runs, it presents 10 randomly selected math questions from a stored list, accepts the user's answers as input, checks each answer against the correct value, and displays the number of correct answers as output."

Notice: the strong response gives the purpose (help students practice, track improvement) separately from the function (presents questions, accepts answers, checks them, displays score).

Response 3b: Data Abstraction

What you need to address:

• Include the two code segments (list creation/modification AND list access).
• Identify the name of the list.
• Describe what the data in the list represents.
• Explain how the list is being used in each code segment.

Common mistake: students describe what the code does without naming the list or explaining what the data represents. "The list stores information that is used later" is not sufficient. Name it: "The list questions stores the text of each math question as a string."

Response 3c: Managing Complexity

What you need to address:

• Explain how the list manages complexity in the program.
• Specifically: why is using a list better than using individual variables for the same data?

This response must make a specific comparison. Saying "the list makes the program easier to manage" is too vague. You need to explain what would be harder without it.

Weak response: "The list manages complexity because it stores all the questions in one place, which makes the program easier to work with."

Strong response: "Without the questions list, each math question would need its own variable: question1, question2, question3, and so on. With 10 questions, I would need 10 separate variables, and the loop that iterates through them would be impossible to write without a list. Using a list allows the program to process any number of questions with a single loop and a single variable name, making the code shorter and easy to extend if more questions are added."

Response 3d: Procedural Abstraction

What you need to address:

• Include the two code segments (procedure definition AND procedure call).
• Describe what the procedure does and how it contributes to the overall program.
• Explain what the parameter represents and how it affects the procedure's behavior.

Common mistake: describing what the procedure does without explaining how the parameter changes its behavior. If the parameter doesn't visibly affect the output in your explanation, the grader can't confirm it satisfies Row 4.

Strong response structure: "The procedure checkAnswer(userInput, correctAnswer) compares the user's answer to the correct answer and returns True if they match, False otherwise. The parameter userInput is the value entered by the user for a given question, and correctAnswer is the expected value stored in the answers list. Because both parameters vary with each question, the procedure produces a different result each time it is called, making it reusable across all 10 questions rather than requiring separate comparison code for each one."

Response 3d (continued): Algorithm Implementation

The same response also asks you to explain, in detail, how the algorithm in your procedure works. This is where you demonstrate that the procedure contains sequencing, selection, and iteration.

Don't just say "my procedure uses a loop and an if statement." Walk through the logic step by step:

"The procedure first initializes a score counter to 0 (sequencing). It then iterates through each index of the questions list (iteration). For each question, it checks whether the user's stored answer matches the correct answer at the same index (selection). If they match, the score counter is incremented by 1. After the loop completes, the final score is returned."

Using the words "sequencing," "selection," and "iteration" explicitly in your response is fine and makes it easier for the grader to confirm you've addressed all three.

Response 3e: Testing

What you need to address:

• Describe two calls to your procedure with different arguments.
• Describe what the result of each call was.
• Explain the condition each call was testing.

The most common mistake on this response: describing conditions instead of arguments. The prompt asks what arguments you passed, not just what situation you were testing.

Weak response: "I tested my procedure when the user's answer was correct and when it was incorrect."

Strong response: "Call 1: I called checkAnswer('42', '42'), passing identical strings as both arguments. The procedure returned True, confirming that the selection correctly identifies a matching answer. Call 2: I called checkAnswer('15', '42'), passing a wrong answer as the first argument. The procedure returned False, confirming that the selection correctly identifies a non-matching answer and does not award credit for an incorrect response."

The strong response names the actual arguments passed, states the actual result, and explains what condition was being tested. All three elements are required.

The Complete Pre-Submission Checklist

Before you submit, go through this list. Each item corresponds to a rubric row.

Also confirm:

• All written responses are within the College Board's word limits.
• Code segments are clearly readable in the submitted PDF (no text cut off, font size is legible).
• The video file meets the format and size requirements specified in the task guidelines.
• The procedure you reference in Rows 4, 5, and 6 is the same procedure throughout.

Frequently Asked Questions

Can I use a program I built earlier in the course?

Yes, with restrictions. The program must be your own work, and you must be able to explain every part of it in the written responses. If you didn't write a section of the code yourself, you cannot use it for Rows 4 or 5. Programs built entirely with drag-and-drop tools or generated by AI without your input do not satisfy the rubric's requirement for a student-developed procedure.

Does my list have to store a specific type of data?

No. Lists can store numbers, strings, booleans, or objects. What matters is that the list is used to manage complexity (Row 3) and that data from it is both stored and accessed (Row 2). A list you create but never read from won't satisfy Row 2b or Row 3.

What if my procedure calls a built-in function inside it?

That's fine. The procedure itself must be student-developed (you wrote it), but it can call built-in functions inside it. What won't work is submitting a built-in function as your "student-developed procedure." The procedure must be defined by you, not provided by the language or a library.

My procedure does three things. Which one do I write about?

Write about whichever one satisfies Rows 4, 5, and 6 most clearly. If you have a procedure that contains a loop with a conditional inside it and uses a parameter that affects the output, that's your Row 4/5/6 procedure. Use that one consistently across all three rows.

Can I change my program after the deadline?

No. Once the submission deadline passes, no changes are accepted. This is another reason to complete the checklist before submitting rather than assuming you can fix things later.

Want Feedback on Your Create Task?

The single highest-leverage thing you can do before submitting is get feedback from someone who knows the rubric. ExamReadyUSA's AP CSP Crash Course includes dedicated Create Task review: Namrata Poladia reads your code and written responses, identifies which rubric rows are at risk, and gives specific feedback on how to strengthen each response before you submit. She has scored real AP CSP Create Tasks as a College Board AP Reader, so she knows exactly what earns points and what doesn't.