Prototyping

Lab setup

First, make sure you have completed the initial setup.

If you are part of a course

  1. Open Terminal. Run the update command to make sure you have the latest code.
    $ mwc update
  2. Move to this lab's directory.
    $ cd ~/Desktop/making_with_code/pilot/labs/lab_prototyping
    

If you are working on your own

  1. Move to your MWC directory.
    $ cd ~/Desktop/making_with_code
    
  2. 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:

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.

๐Ÿ’ป 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:

  1. 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?
  2. Describe a moment in a usability test when a user got stuck. What did it teach you?
  3. How did you use the agent to build your interactive prototype? What did you have to correct?
  4. Which problem in the evaluation you received was most useful, and how will you respond?