Prototyping
Lab setup
First, make sure you have completed the initial setup.
If you are part of a course
-
Open Terminal. Run the update command to make sure you have the latest code.
$ mwc update -
Move to this lab's directory.
$ cd ~/Desktop/making_with_code/pilot/labs/lab_prototyping
If you are working on your own
-
Move to your MWC directory.
$ cd ~/Desktop/making_with_code -
Get a copy of this lab's materials.
git clone https://git.makingwithcode.org/founders-studio/lab_prototyping.git
With an AI coding agent, you can build a working app in an afternoon. So why would anyone make a prototype out of paper? Because a prototype isn't a small version of the product. It's a question: a way to test an assumption as cheaply as possible, before you've invested in the answer. In this lab, you will build prototypes at increasing levels of fidelity, test them with real users, and evaluate another team's work.
By the end of this lab, you will be able to:
- Design a prototype to test a specific assumption.
- Run a usability test and learn from it without leading the user.
- Use an AI coding agent to build an interactive prototype quickly.
- Evaluate a design with usability heuristics, and respond to an evaluation of your own.
Experience prototypes
An experience prototype tests one critical assumption by acting out or simulating the experience, before anything is built. For example, to test whether students would trade shifts with strangers, you might post a fake "shift swap" board in a break room for a day, and see whether anyone uses it.
๐ป Start from the critical assumption of your chosen concept from
Concept iteration. Design three experience
prototypes, each testing a different assumption. Describe each in experience.md: what it
tests, how, and what result would change your mind.
๐ป Run your experience prototypes and record what happened.
Paper prototypes
A low-fidelity prototype shows the main screens and steps of your concept, roughly. A paper prototype is drawn by hand: one sheet per screen, with a teammate playing "computer" by swapping sheets as the user taps.
Paper prototypes are fast to make and fast to change. Just as important, users can tell they're unfinished, so they feel free to criticize. A polished screen invites comments about colors; a sketch invites comments about whether the idea works.
๐ป Choose two or three key tasks a user would do with your concept. Draw a
paper prototype that supports them. Take photos and save them in paper/.
Usability testing
In a usability test, you give a user a task and watch them try to do it with your prototype.
- Give a task, not instructions. "Find a shift to swap next Tuesday," not "tap the calendar icon."
- Ask them to think aloud. Ask the user to say what they are looking at, thinking, and trying to do.
- Don't help. When the user gets stuck, resist explaining. Ask, "What would you expect to happen?" Getting stuck is the most useful thing that can happen in a test.
- Take notes on what they do, not just what they say.
๐ป Test your paper prototype with at least three people from your target
group. Record notes in testing.md: where they got stuck, what surprised them, and what
surprised you.
๐ป Revise your paper prototype, and test it again.
Interactive prototypes
Now that your concept has survived contact with real users, it's worth making it interactive. A medium-fidelity prototype lets users click or tap through the core tasks, even though nothing behind the screens really works.
๐ป Use Claude Code to build an interactive prototype of your core tasks in
the prototype/ folder. Give the agent your photos of the paper prototype and your testing
notes as context. Ask it to build only what's needed for the tasks you're testing, with fake
data.
๐ป Start the prototype and click through it yourself.
$ cd prototype
$ python -m http.server
Then open http://localhost:8000.
๐ป Test the interactive prototype with users, as before, and record the
results in testing.md.
Heuristic evaluation
A heuristic evaluation is a review of a design against a list of usability principles (heuristics). Experts use them to catch problems quickly, before testing with users.
๐ Read heuristics.md, which lists ten widely used usability heuristics
(Jakob Nielsen's), such as visibility of system status ("the design should always keep
users informed about what is going on") and error prevention.
๐ป Your team will evaluate another team's prototype. First, each person evaluates it alone: work through the prototype, and for each problem, note which heuristic it violates and how severe it is (from 1, cosmetic, to 4, catastrophic).
๐ป Then combine your findings as a team into evaluation.md, removing
duplicates and agreeing on severity. Give the evaluation to the other team.
๐ป When you receive an evaluation of your own prototype, write a response
in response.md: for each problem, will you fix it, and how? If not, why not?
Deliverables
๐ป Answer these questions in questions.md:
- What was the most important thing you learned from your experience prototypes or paper prototype? Would you have learned it if you had skipped straight to code?
- Describe a moment in a usability test when a user got stuck. What did it teach you?
- How did you use the agent to build your interactive prototype? What did you have to correct?
- Which problem in the evaluation you received was most useful, and how will you respond?