What Is the AP CSP Create Task?
The AP CSP Create Task is the scored performance task in AP Computer Science Principles where you design and build a program of your own, record a short video that shows the program running, and prepare a Personalized Project Reference (PPR) with specific code segments you will explain on the end-of-course exam. It is not a paper about coding; it is evidence that a real program works, meets stated requirements, and can be described with the same precision you would use in a technical walkthrough.
Because the Create Task is part of your AP score, treat it like a small product release: define the user problem, choose inputs and outputs you can demonstrate, and keep a written trail of what you tried when something failed. When you plan, draw the same connections you studied in AP CSP Unit 1: Creative Development—purpose, user stories, iteration, and debugging notes—so your final submission reads as one coherent story instead of a last-minute file dump.
On exam day, written prompts expect you to point to the code you captured in the PPR. That means the Create Task is two linked deliverables: the running program you submit in the Digital Portfolio, and the frozen snippets you will reference under time pressure. If those snapshots omit your list usage, your procedure header, or the branch and loop you rely on to explain complexity, partial credit becomes difficult even when the full project file is impressive.
AP CSP Create Task Requirements
College Board expects a program you authored that runs as submitted, interacts with a user while it runs (not only pre-filled constants), produces output a user can observe, manages a collection such as a list, includes a procedure you wrote that uses parameter(s) to change behavior, and uses sequencing, selection, and iteration in meaningful program logic. You also submit a short video and a PPR PDF that match the version of the program you intend to discuss on the exam.
| Requirement | What it means | Common mistake |
|---|---|---|
| Purpose-driven program | You can state the goal of the software in plain language and the running build shows that behavior for the features you claim. | Declaring a tall feature list while the submission only demos one shallow path—or crashes when graders follow printed steps. |
| Input during execution | While the program is running, a user supplies data or choices through a prompt, form field, clicks, sensors, blocks, or other accepted interaction—not only hard-coded literals. | Showing typed values that were baked into the source file with no realistic user entry path in the demonstration. |
| Output based on processing | Readable or audible results appear after computation (text on screen, images drawn within the UI rules, synthesized audio, actuator behavior), tied to variables or state transitions you can cite. | Printing a static banner that never changes with input or hiding the meaningful output off-screen in the recording. |
| List or collection used in code | Your program creates or updates a list (or similar collection) and later reads from it to support the user-facing outcome. | Declaring a structure that never changes or tagging an unused scaffold while the core logic ignores the collection entirely. |
| Student-developed procedure with parameters | You ship a reusable chunk of logic you wrote whose parameters influence outputs, stored data, control flow paths, or list updates—not just ceremonial names. | Adding parameters that never affect an output path or list mutation—reviewers score the requirement on whether the inputs change observable behavior. |
| Sequencing, selection, iteration | Ordered steps execute in sequence, branching handles cases, and a loop revisits instructions based on a condition or collection traversal. | Claiming “there is a loop somewhere” while the submitted snippet set omits the construct you need to explain under exam pressure. |
| Portfolio artifacts and integrity | You upload the program code as a PDF, an MP4 within the time cap, and a PPR PDF that aligns with the code you froze; collaboration rules allow planning help but not joint finalization of those artifacts. | Finishing the video or PDFs as a group product, or editing code after the PPR no longer matches what you will reference on the exam. |
- Run longer than one minute.
- Replace live input evidence with narration-only claims.
- Show phone numbers, full names, school IDs, home addresses, or other personally identifiable information.
- Depend on network assets you cannot guarantee will load for a reviewer.
- Be a slideshow of static screenshots without the program executing.
- Hide the input-to-output chain behind effects that distract from the actual interaction.
Languages you may use: You can complete the Create Task in any language or environment your teacher approves as long as you can export the required PDFs and produce the MP4—common choices include Python, Java, JavaScript with HTML canvas or simple DOM I/O, C#, Snap!, Scratch, App Inventor, and similar block- or text-based tools. Pick the stack you can explain aloud without guessing, because the score depends on your analysis, not on using a particular syntax. Double-check the current portfolio instructions on the College Board AP Computer Science Principles assessment page each year for format changes.
AP CSP Create Task Rubric
The Create Task rubric awards up to six points—one point per row—and each row is evaluated against the evidence in your program, video, and written responses. Think of every row as a contract: if a reviewer cannot trace the requirement to a concrete behavior in your submission, that row is at risk even when the project feels “almost done.”
| Rubric row | What reviewers look for | Evidence you should be ready to show |
|---|---|---|
| Program purpose and function | The program’s goal is clear and the demonstrated features run without errors for the path you show. | A one-sentence purpose in your write-up plus a clean demo where input leads to the output you describe. |
| Data abstraction (list/collection) | A list or collection stores data that matters to the program and is accessed with meaningful names or indices. | PPR segments that show creation or update and a read that affects user-visible results. |
| Managing complexity with the list | The collection reduces duplicated logic or organizes information more cleanly than scattering unrelated variables. | A short explanation comparing “with list” vs. “without list” for the same feature. |
| Procedural abstraction | A student-authored procedure uses parameter(s) to change outcomes, data, or control flow in a way that matters to the user story. | Two calls with different arguments that produce different outputs or list states in testing notes or the recording. |
| Algorithm implementation | Sequencing, selection, and iteration all appear in substantive logic—not only trivial wrappers around library calls. | Annotated excerpts where graders can spot a branch and a loop tied to the algorithm you explain. |
| Testing and iteration narrative | You describe purposeful tests or revisions that respond to behaviors you observed, not vague “fixed stuff” commentary. | Named inputs, expected versus actual outputs, and the code edits that closed the gap. |
- Parameter theater: The procedure accepts an argument but the body ignores it when deciding prints, storage, or return values.
- Decorative collections: A list exists in the file yet the interesting behavior could run identically without ever mutating or reading it.
- Thin testing stories: Responses say “It worked” without tying failures to specific inputs, outputs, and code changes—so the testing row cannot credit real iteration.
Best AP CSP Create Task Ideas
The strongest Create Task topics are narrow enough to finish, rich enough to require a list plus a parameterized procedure, and easy to demo in sixty seconds without exotic hardware. Aim for interactions you can rehearse repeatedly: predictable prompts, clear outputs, and a single “golden path” for the recording that still proves your branching and looping logic.
Beginner-friendly builds (minimal UI risk)
- Vocabulary drills: Store terms and definitions in parallel lists or structured rows; a procedure picks a difficulty flag or lesson set and updates what the user sees next.
- Personal budget snapshot: Append spending entries to a list; a procedure recalculates category totals when a user switches the month or cap parameter.
- Simple inventory: Track item names and counts; a procedure applies a restock or discount rule based on a numeric threshold parameter.
- Class helper randomizer: Keep a roster list; a procedure filters by group id or team size before drawing names without replacement.
- Study streak tracker: Log daily minutes in a list; a procedure recomputes streak length or weekly goals from a target parameter.
- Quiz scorekeeper: Maintain running points per round in a list; a procedure adjusts scoring rules (double points mode) through a boolean-like flag.
- Playlist builder: Store song titles; a procedure sorts or filters by genre parameter before printing the next subset.
- Survey tally board: Collect counts across options in aligned lists; a procedure resets or locks voting based on a mode parameter.
Stronger scope (still portfolio-safe if you cap features)
- Adaptive practice engine: Rotate questions based on previous misses stored in lists; a procedure chooses the next item using a difficulty parameter.
- Event signup waitlist: Model attendees in a list; a procedure promotes waitlisted users when capacity or priority parameters change.
- Small simulation: Step through daily states kept in lists; a procedure applies growth or decay rules using a rate parameter each tick.
- Two-player turn game (lightweight): Track board or move history in lists; a procedure validates plays with a rule-set parameter to keep branches visible.
- CSV-lite grade reporter: Parse simple lines into lists; a procedure computes statistics for a chosen column index parameter.
- Text adventure node map: Represent rooms and items as parallel lists; a procedure resolves actions keyed by verb and noun parameters.
- Photo metadata tagger: Store captions and labels in lists; a procedure filters visible photos by tag parameter.
- Small fitness planner: Log sets and reps; a procedure projects weekly load when users adjust a intensity parameter.
Ideas to avoid unless you shrink them fast
- Online multiplayer backends you cannot reliably demonstrate offline.
- Heavy 3-D engines where debugging buries rubric-visible logic.
- Projects that need secret API keys or paid services reviewers cannot access.
- Glossy portfolios with copy-pasted tutorials and no individualized procedure.
- Anything that hides list usage inside an opaque helper you did not author.
- Scopes that demand more art than algorithm work before the deadline.
AP CSP Create Task Examples
Use these patterns as rehearsal objects: they rehearse list usage, parameterized procedures, and written explanations that mirror the kinds of prompts you see after submission. Translate names and behaviors into your course language, then swap every identifier so the work is unmistakably yours.
Vocabulary quiz walkthrough tied to portfolio evidence
- List role: Store word–definition pairs while the user progresses; show how insertion or reordering responds to correctness.
- Procedure role: Pass a difficulty string or numeric level so the quiz surfaces different slices of the collection.
- Algorithm role: Branch on right versus wrong answers and loop until a session limit or mastery count is reached.
- Testing role: Capture at least one wrong answer path and the fix that stopped double-counting points or repeated questions.
- Video role: Film prompt entry, an immediate branch change, and the final score output without scrolling past the evidence.
Pseudocode for a checkAnswer procedure (language-agnostic)
Adapt syntax to your environment, rename variables for clarity, and ensure the appended values are read later—graders trace how list mutation supports scoring, not just that a helper exists.
Written response prompt templates you can rehearse aloud
- Purpose framing: “My program helps [user] accomplish [goal] by accepting [inputs] and returning [outputs] so that [measurable outcome].”
- List simplification: “Without the list, I would repeat [duplicated work]; storing [data elements] lets the loop [short description] iterate once.”
- Procedure with parameters: “The procedure [name] takes [parameters]. When I pass [value A], the program [behavior]; when I pass [value B], it [different behavior].”
- Testing narrative: “I typed [input]; I expected [output] but observed [failure]. I changed [snippet] so that [new behavior].”
Video demo tips recorded projects use most
- Reboot the build so the splash screen proves you launched the exact submission—not an older shortcut.
- Film the keystrokes or taps that constitute input; freeze for a breath on outputs so OCR and human eyes alike catch the linkage.
- Prefer one cohesive scenario over hopping across half-finished tabs that blur the causal chain.
- Show the procedure’s effect twice with different arguments or toggles aligned with your written rehearsal script.
- Normalize resolution and scaling so graders never hunt for microscopic UI chrome.
- Caption optional on-screen reminders are fine only if College Board publishing rules permit them—never replace live execution with overlays alone.
How to Submit
Submit each Create Task artifact through the AP Digital Portfolio, confirming every upload independently and leaving time for your teacher’s approval ahead of College Board deadlines. Missing one “Final Submit” state can zero the impacted component even if files sit in draft folders.
- Sign into AP Classroom and open the Digital Portfolio at digitalportfolio.collegeboard.org, matching the roster course your teacher monitors.
- Freeze the code snapshot you intend to reference, export or print-merge it into the required program PDF layout, and page through every sheet for truncation or clipped margins.
- Produce the MP4 at or below the sixty-second ceiling; scrub audio for unintended personal details and rerun the clip to verify legible typography.
- Generate the Personalized Project Reference after the freeze, tagging only sanctioned segments without sneaking in patched lines you will not defend on exam day.
- Upload each artifact in its labeled slot—program PDF first if that helps QA, yet always finish all three confirmations before you celebrate.
- Alert your instructor immediately after each finalized upload so confirmations register while upload windows remain open.
- Late freezes: Coding after exporting the PDF or PPR, which leaves exam citations pointing at vanished lines.
- Wrong compression: Over-shrinking video until on-screen prompts become unreadable, breaking the requirement chain.
- Unchecked teacher workflow: Assuming auto-approval exists when portfolios still demand manual endorsement before hard deadlines.
- Format drift: Ignoring yearly tweaks on the official assessment page until upload validators reject filenames or codecs.
Keep the authoritative submission rules beside you while exporting: bookmark the College Board CSP assessment hub (AP Central CSP assessment) and reconcile requirements the week portfolios lock.
AP CSP Create Task Planning Template
Use this fillable template to plan your Create Task before you write any code. Save your answers (or print them) and use them as a guide while building.
Common Create Task Mistakes
| Mistake | Why it costs points | Better choice |
|---|---|---|
| Procedure parameter is never used | Row 4 of rubric requires the parameter to affect behavior | Make the procedure produce different output for different arguments |
| Hardcoded values instead of input | Program looks like it does not accept input | Use a real input mechanism — text field, button, file read |
| Tests described as "I tested it" | Row 6 wants specific calls with specific results | Write two specific calls with arguments and outputs |
| Video over 1 minute | Graders cut off at 1 minute | Trim, speed up, or remove non-essential parts |
| Showing your face or name on screen | Violates anonymity rules | Re-record without identifying info |
| Code copied from a tutorial | You cannot explain it on exam day | Build something small but original |
| Single feature with no logic | No procedure or algorithm to describe | Add at least one decision and one loop |
How APScore5 Helps You Prepare
Use APScore5 to practice the Unit 1 concepts the Create Task tests — collaboration, program design, iteration, testing, and documentation — and to drill the MCQ patterns that show up alongside the Create Task in your AP CSP score.
Frequently asked questions
When is the AP CSP Create Task due?
The Create Task is usually due in late April, before the AP CSP exam in May. Your exact deadline is set by your teacher inside AP Classroom — log into your AP Digital Portfolio to see your personal due date. Don't wait until the last week; most students need at least 9 class hours, plus extra time at home for testing and recording.
How do I submit the AP CSP Create Task?
Submit through the AP Digital Portfolio, which you reach from your AP Classroom account. You'll upload three separate files — your program code as a PDF, your video as an MP4, and your Personalized Project Reference as a PDF — and hit "Final Submit" on each one separately. Your teacher then has to confirm your submission before the deadline, so don't submit on the very last day.
Where do I submit my AP CSP Create Task?
Everything goes into the AP Digital Portfolio at digitalportfolio.collegeboard.org, which you can also reach through AP Classroom. You'll see three upload slots, one for each piece. Your teacher gets notified when you submit, but they need to approve before the final deadline — give yourself a couple of days of buffer in case anything needs a fix.
What are the AP CSP Create Task requirements?
You need a working program you wrote yourself, a video that's 1 minute or shorter showing the program run, and a Personalized Project Reference containing the code segments you'll write about on exam day. Your program must include input, output, at least one list or collection, a procedure you wrote with a parameter, and code that uses sequencing, selection, and iteration. Collaboration is allowed while you plan and learn, but not while you record the video or finalize the submission.
What is the AP CSP Create Task rubric?
The rubric has 6 rows, each worth 1 point, for a total of 6 possible points. Graders check program purpose and function, how your code uses a list, whether the list makes your code simpler, whether your procedure's parameter actually changes the behavior, whether your algorithm uses sequencing/selection/iteration, and how clearly you describe testing. Most students lose points on the procedure row — make sure your function actually uses its parameter inside the procedure, not just accepts one.
Can I use Python for the AP CSP Create Task?
Yes, Python is one of the most common languages students use for the Create Task. You can also use JavaScript, Java, Snap!, App Inventor, Scratch, or pretty much any other text-based or block-based language. Graders aren't testing whether you know Python — they're testing whether you can explain what your code does and why, so use whatever language you can speak about most clearly.
How long should my AP CSP Create Task video be?
One minute or shorter. The video has to show your program actually running — input being entered, the input getting processed, and the output appearing. You don't need voiceover, you shouldn't show your face or name, and most strong videos are 30-45 seconds because clarity matters more than length.
What happens if I run out of time before the deadline?
Submit what you have before the deadline, even if it's not finished — a partial submission can still earn points, but a missing one earns zero. If you're behind, drop your weakest feature, make sure your program runs without crashing, and focus on writing a strong Personalized Project Reference. An incomplete program with a clear procedure and working output usually scores better than a half-finished project with bugs everywhere.