Program Development Process: How Programmers Plan, Build, and Improve Programs
Unit 1 · Concept 2 of 5 · ~8 min read · 10–13% of AP exam
By APScore5 Editorial Team · AP CSP Subject Specialists
The steps programmers use to turn an idea into a working program — investigate, design, prototype, test, refine, and document — with examples built around AP CSP projects.
The program development process is the series of steps programmers use to turn an idea into a working program. It usually includes investigating user needs, designing the solution, writing code, testing it, refining it, and documenting the work. Programmers often move back and forth between steps rather than following them in a straight line.
Updated May 2026Reviewed by APScore5 Editorial TeamAP Computer Science Principles Big Idea 1
7 main stepsNon-linear flowTested in MCQsUsed in Create Task
The program development process is the set of steps programmers use to turn an idea into a working program — investigating, designing, building, testing, refining, and documenting. The exact list varies by class and language, but every version includes planning before code and testing after.
Real programmers don't sit down and type out a finished program. They start by figuring out what the program should do, who will use it, and what data it needs. Then they sketch a design — sometimes on paper, sometimes in code comments — before writing the first real line. Once code exists, they test it, find what's broken, fix what's broken, and repeat. After the program works, they add documentation so the next person (or their future self) can understand it.
The AP Computer Science Principles exam treats this process as a core idea of Big Idea 1: Creative Development. You won't be asked to recite the steps in order — you'll be given a scenario and asked things like "what should the student do next?" or "which step did the student skip?". Knowing the process helps you answer those questions and helps you build a stronger Create Task project.
The process is also why programmers work in teams. Different people are stronger at different steps — some at design, some at testing, some at debugging. Collaboration in computing often makes each step go faster and produce better results.
Step by step
The Main Steps of Program Development
The program development process has 7 main steps: investigate, design, prototype, test, refine, document, and iterate. Most projects loop through testing and refinement multiple times before they're done.
Step
What it means
AP CSP student example
1. Investigate
Decide what the program should solve and who will use it
"AP CSP students who want vocabulary practice"
2. Design
Plan features, inputs, outputs, and logic
Flashcard screen, answer checker, score tracker
3. Prototype
Build a simple working version with one feature
One question at a time, no scoring yet
4. Test
Run the prototype with different inputs
Correct answers, wrong answers, blank answers
5. Refine
Improve based on what testing revealed
Fix the blank-answer crash; add score tracking
6. Document
Add comments and notes explaining your code
"This procedure checks if the answer is correct"
7. Iterate
Return to earlier steps as new ideas come up
Add a new feature, test it, refine it, document it
Why each step matters
Investigate — Skipping this step is the #1 reason Create Task projects fail. If you don't know what problem you're solving, you can't write a strong purpose statement on exam day.
Design — Writing code without a design is like building a house without a plan. You'll spend more time rewriting than building. Design can be as simple as a list of features on a sticky note.
Prototype — Build the smallest version that does something. A working one-question quiz is better than a half-finished ten-question quiz.
Test — Programmers spend more time testing than writing new code. See the full program testing page for what to test and how.
Refine — This is where good programs become better. Refinement is part of iterative development — small improvements over time.
Document — Comments and notes help future-you and any teammate understand the code. See the program documentation page for what good documentation looks like.
Iterate — After you ship one feature, new ideas arrive from users or teammates. Iteration means repeating earlier steps on purpose: add the feature, test it, refine it, document it, then decide whether to loop again. That rhythm is iterative development in practice, not a separate shortcut around the process.
Quick reference: seven steps of program development
Investigate the problem — decide what the program should solve and who will use it (for example, AP CSP students who want vocabulary practice).
Design the solution — plan features, inputs, outputs, and logic (flashcard screen, answer checker, score tracker).
Prototype — build a simple working version with one feature (one question at a time, no scoring yet).
Test the prototype — run it with different inputs (correct answers, wrong answers, blank answers).
Refine based on testing — improve what testing revealed (fix the blank-answer crash; add score tracking).
Document the code — add comments and notes (for example, "This procedure checks if the answer is correct").
Iterate — return to earlier steps as new ideas come up (add a feature, test it, refine it, document it).
On the exam, stimuli often show an artifact — interview notes, a test log, or a comment block — and ask you to name the step or the best next step. Match the artifact to the step: interviews point to investigate, test tables point to test, comments point to document.
Reality check
Why the Program Development Process Is Not Linear
Real programmers move back and forth between steps. You might be testing your code, realize the design has a flaw, go back to the design step, then return to building. Each cycle makes the program better.
Example: A student building a quiz app starts with this plan: show a question, take an answer, score it. They prototype it. During testing they realize most users hit "skip" before answering. They go back to design, add a "skip" option, build it, test it, then realize they need to also track skipped questions in the score. They refine again.
That back-and-forth is normal. The AP CSP exam often tests whether you recognize it — questions might describe a programmer who tests, then changes the design, then tests again. The correct answer usually involves iteration, not "the programmer skipped a step."
Exam lens
Program Development in AP CSP
AP CSP tests the program development process in two ways: multiple-choice questions on the exam (10–13% of MCQs) and the Create Task performance task, where you actually go through the process and write about it.
On the multiple-choice exam
Look for questions that describe a scenario and ask "what should happen next?" or "which step did the student do well?". The correct answer usually involves one of these moves:
Testing before adding more features
Refining based on user feedback
Documenting decisions so a teammate can understand
Returning to design after testing reveals a problem
On the Create Task
The written responses on exam day directly ask about steps of this process. You'll describe your algorithm (the design step), explain a procedure (the build step), and describe your testing with specific inputs and outputs (the test step). Going through the full process while building means you'll have real things to write about on exam day.
Official standards for Big Idea 1 appear on College Board AP Central under Creative Development. Use that page to confirm vocabulary, then return here for AP-style scenarios and practice.
🎯
How this shows up in the Create Task
When you build your Create Task project, you'll move through every step of the program development process — investigating, designing, prototyping, testing, refining, and documenting. The written responses on exam day ask you to describe your algorithm and your testing, which are two specific steps of this process. The students who score 5s usually went through the full cycle at least twice.
Drag the rows into the order AP CSP typically expects before teams loop backward. Use "Check my answer" for feedback; after two attempts with mistakes, the answer key appears so you can reconcile wording. This exercise is meant to teach, not trick — use the one-line tip beside each step in the answer key after you submit.
Correct order:
Investigate the problem — Start by naming the user problem before you open the editor.
Design the solution — Plan inputs, outputs, and logic on paper or in comments.
Build a prototype — Build the smallest version that does one thing.
Test the prototype — Run the program with normal, edge, and invalid inputs.
Refine based on testing — Fix what testing revealed before adding features.
Document the code — Add comments that explain decisions, not just syntax.
Iterate (return to earlier steps with new ideas) — Loop back when you learn something new.
Avoid traps
Common Mistakes Students Make
Mistake
Why it causes problems
Better approach
Starting with code before planning
Program ends up disorganized; you can't explain your design choices
Spend 10 minutes writing a list of features before opening the editor
Skipping the test step
Bugs hide until exam day, and your testing response will be weak
Test after every small feature, not at the end
Testing only with correct inputs
The grader on row 6 of the rubric wants two specific calls — both should reveal different behavior
Test with normal, edge, and invalid inputs
Not documenting anything
Future-you can't remember why you wrote something; written responses are harder
Add a comment every time you make a decision
Choosing a project that's too large
You'll run out of time before testing
Pick something you can finish in 6 hours; spend the other 3 hours refining
Treating the process as one-and-done
You miss the chance to refine
Plan to iterate at least twice
Timed reasoning
AP-Style Practice
Click an answer to see whether you are correct and unlock the explanation. Five questions cover common AP CSP stems plus two harder scenarios about testing evidence and skipping prototype cycles.
1. A student is building a quiz app for AP study. They write all the code first, then test it once at the end. They find five bugs. Which step of the program development process did the student skip or shorten?
Easy
Answer: C. The student tested once at the end instead of testing throughout. Iterative testing finds bugs earlier when they are easier to fix. Testing only at the end means all five bugs compound.
Why D is wrong: Documentation matters, but the specific problem here is timing of testing, not lack of comments.
2. During testing, a student realizes their program's design has a flaw — the "submit" button doesn't fit on small screens. What is the best next step?
Easy
Answer: B. Real programmers move back and forth between steps. Discovering a design flaw during testing is normal — the right move is to return to design and refine.
3. A teammate suggests an improvement after seeing the prototype. The student adds it, tests it, and finds it works. What name best describes this process?
Medium
Answer: B. Iteration means returning to earlier steps to improve the program. Adding a suggested feature, testing it, and confirming it works is one full iteration.
4. A team finishes a Create Task prototype, writes comments describing each procedure, then runs the program once with valid inputs only. A classmate later discovers the app crashes when the list is empty. Which mistake best explains the gap?
Hard
Answer: B. Comments are documentation, not a substitute for test evidence. An empty list is a classic edge case — AP rubrics expect you to test inputs that reveal different behavior, not only the happy path.
AP tip: Pair every refine story with the test input that forced the change.
5. During review, a student says they moved from design straight to final submission without a smaller test build because the teacher already approved the project idea. What is the strongest AP CSP critique?
Hard
Answer: C. Teacher approval can end investigation, but it does not replace prototype and test cycles. Without a working partial build and logged tests, you have little to describe on exam day about how your algorithm behaved with real inputs.
AP tip: Approval of an idea is not evidence that the program was tested.
Confidence gate
What You Can Now Do
Tick each line when you can explain the idea out loud without peeking at the table above.
0 of 5 ready
Quick answers
Frequently Asked Questions
What is the program development process?
The program development process is the set of steps programmers use to turn an idea into a working program. It usually includes investigating user needs, designing the solution, building a prototype, testing it, refining based on what testing reveals, and documenting the code. Programmers move back and forth between steps rather than going through them once in order.
What are the steps of program development?
Most versions of the process list 7 steps: investigate, design, prototype, test, refine, document, and iterate. Some textbooks combine refine and iterate into one step, and some add a "deploy" step at the end. For AP CSP, focus on the idea that planning happens before code and testing happens throughout — not just at the end.
Why is iteration important in program development?
Iteration means returning to earlier steps to improve the program after you've learned something new. Without iteration, you'd have to plan everything perfectly the first time — which never happens in real coding. Programmers who iterate catch bugs earlier and end up with stronger programs because each cycle makes one small thing better.
What is the difference between program design and program development?
Design is one step inside the larger development process. Design is where you plan inputs, outputs, and logic before writing code. Development is the whole journey — investigate, design, prototype, test, refine, document. You can think of design as a sketch, and development as the full process from idea to finished program.
How does the program development process connect to the AP CSP Create Task?
The Create Task asks you to actually go through this process and write about it. Your written responses on exam day ask about your algorithm (the design step), your procedure (the build step), and your testing with specific inputs and outputs (the test step). Students who go through the full cycle at least twice usually score better because they have more to write about.
Why is documentation part of the program development process?
Documentation is what lets someone else (or future-you) understand your code. Comments explain why you made decisions, not just what the code does. On the Create Task, strong documentation makes your written responses much easier to write because you've already recorded your thinking.
What is a program development life cycle?
"Life cycle" is another name for the program development process, often used in software engineering. It usually has the same steps — plan, design, build, test, deploy, maintain — though the names vary. For AP CSP, "program development process" and "program development life cycle" mean essentially the same thing.
How is software development different from program development?
Software development usually refers to building larger systems with multiple programs, often by teams over months or years. Program development refers to building a single program, which is what AP CSP focuses on. The steps are similar, but software development adds extra steps like version control, deployment, and long-term maintenance.