Guided audio walkthrough
Press play and listen. The narrator walks you through the whole workflow one step at a time, points you to the diagram for each step, and stops when it's time for you to do something. Choose your level, Claude plan and view at the top; everything changes to match.
Every diagram for this level and plan, in order, with no narration. Use the Download SVG buttons to drop them into slides. Exports keep the current light or dark theme.
How to use it: press ▶ in the player bar, or "Play section" on any step. At each "Pause here" the narrator stops automatically. Do the step in the Prompt Studio, then press play to carry on. Space bar also plays and pauses. Diagrams light up as the narrator reaches them, and prompt cards are ready to copy. Switch the view to Diagrams for a picture-only version.
Your browser has no read-aloud voice. Copy the script below into your device's read-aloud feature or into Claude's voice mode instead.
Copies the current level and plan as plain text, ready for another reader.
Welcome to Level 1
Hello, and welcome. This walkthrough guides you through Level 1: building a clickable prototype with Claude. You don't need to know how to code. Claude writes the code. Your job is to describe what you want clearly, judge what comes back, and steer it with small, precise changes. You make the design decisions.
Open the Prompt Studio with the button at the top of this page. It opens in a new tab, already set to Level 1 and your Claude plan. Every diagram you need is on this page, right beside the step it belongs to. The journey has five stages. Pick a design system. Plan your task and screens. Prompt Claude for version one. Fix it in small steps. Then finish and share it.
Look at the diagram. It shows those five stages in order, from picking a design system to finishing and sharing your prototype.
Whenever you hear me say "pause here", I'll stop automatically. Do that step, then press play when you're ready to carry on. Let's begin.
Step one. Getting set up
You're using the free Claude plan. It includes artifacts. That's the live preview panel where your prototype appears, and you can publish it as a link to share. The catch is usage. Your allowance refills over a rolling window of a few hours, and big builds and long chats use it up fastest. So treat every message as valuable. Think first, prompt second.
You're using Claude Pro. You get at least five times the free plan's usage in each five-hour session, with a weekly cap on top. Pro also gives you Projects. A Project holds your rules, so every chat inside it starts already briefed. We'll use that throughout.
Open claude dot A I and sign in. Check in settings that artifacts are switched on, so a preview panel appears when Claude builds something. Then create a folder on your computer for your prototype. You'll save each version there as version one, version two, and so on. The "Your plan" section of the Prompt Studio has a setup checklist you can tick off as you go.
The diagram shows a simplified Claude screen. You type in the chat on the left. Your prototype appears in the preview on the right, with buttons to download it or publish a share link. The numbered circles match the list under the picture.
- Paste your prompt from the prompt builder.
- Claude replies with a plan. Correct it if needed, then reply
go. - The live preview: click through your main task here.
- Download a copy of every working version; publish to get a share link.
The diagram shows a simplified Claude screen. You type in the chat on the left. Your prototype appears in the preview on the right, with buttons to download it or publish a share link. Number five, at the top, is the Project you're working in.
- Paste your prompt from the prompt builder.
- Claude replies with a plan. Correct it if needed, then reply
go. - The live preview: click through your main task here.
- Download a copy of every working version; publish to get a share link.
- The Project you're working in. Its instructions apply to every chat inside it.
Next, create a Project and name it after your prototype. In the "Your plan" section of the Prompt Studio there's a box called Project instructions. It fills itself in once you've chosen a design system and completed the prompt builder, so you'll copy it into your Project in step four.
The next diagram shows how a Project works. Its instructions and files feed every chat inside it, and you start a fresh chat for each new version.
Pause here and get set up. Press play when you're signed in and have your folder ready.
Step two. Choose a design system
A design system is a kit of ready-made, tested components: buttons, form fields, alerts and so on. Building on one means your prototype looks consistent and professional, instead of using wobbly styling that Claude made up.
Open the Design systems section of the Prompt Studio. Start from your task, not from what looks nicest. Is it a health or care service? Try NHS dot U K. Is it form-heavy, or a step-by-step service? Try GOV dot U K or the U S Web Design System. Lots of dashboards, tables or components? Try Bootstrap or Carbon. Is this your very first prototype? Pico or Bulma will give you the fewest problems.
The diagram turns that into a ladder. Work down the questions and take the first yes. It's a starting point, not a rule.
Every option has a Preview button, so you can see a sample screen before you choose. There's also Tailwind, a flexible styling toolkit that works well as long as you ask Claude for one accent colour and consistent spacing. And there's a no-design-system option, which always loads, even when other files are blocked.
One warning: the government and N H S code is free to use, but their logos, crown and fonts are not. Claude will be told to use a generic header. When you've decided, press Select, and your choice flows straight into your prompt.
Pause here and choose your design system.
Step three. Plan before you build
This step happens before you open Claude. You'll narrow down from a realistic situation to the smallest set of screens someone needs to complete one task.
Start with a situation. For example: your group meets tomorrow and you need a quiet room. Turn it into one main task with a clear end point: book a room for four people, tomorrow, between two and four, and see it in "My bookings". Then list only the screens that task needs. Perhaps five.
The funnel diagram shows the same narrowing: from situation, to task, to what finished looks like, to only the screens the task needs.
Anything outside that list doesn't get built. A prototype is a sketch you can click, not a finished product.
A good check: read your answers to a neighbour. If they can't picture the prototype from your words alone, Claude won't be able to either.
Pause here and write your task and screen list.
Step four. Use the prompt builder
Now open the Prompt builder. Type in your idea, your users, the main task, and your screens one per line. Add any example content you'd like. Then choose the device and the fidelity. Mid fidelity is a sensible default.
Not sure what to write? Above the prompt there are three example buttons: a room booking app, a plant-care tracker, and a café sales dashboard. Press one to fill the whole form and see the prompt it makes. Try another to compare them. Then replace it with your own idea.
Leave "confirm a plan before building" ticked. It costs one short exchange and often saves a complete rebuild.
The prompt it writes has six parts. Format: one H T M L file, with no server. Design system: so your prototype uses real components. The prototype: users, main task, screens and fake content. Requirements: the task must work, it must be accessible, and it must suit the device. Before you build: a plan first. After you build: a plain English explanation.
The diagram lays out those six parts in order, with what each one is for.
On Pro, now go back to the "Your plan" section, copy the Project instructions, and paste them into your Project. They've been filled in from your design system and your answers, and the prompt itself tells Claude to follow them.
Pause here fill in the builder, and copy your prompt.
Step five. Build version one
Start a new chat inside your Project and paste in your prompt. Claude should reply with a short plan, not code. Read it carefully. If anything's wrong, correct it in one reply. When the plan's right, reply with one word: go.
Your prototype appears in the preview panel. Click through your main task from start to finish, and write down every place it breaks or surprises you. Don't ask for any changes yet.
Before you do anything else, download the file and save it in your folder as version one. That way, whatever happens next, you can always go back.
If Claude stops halfway through, reply: "Continue from exactly where you stopped." And if you hit your usage limit, don't panic. Download what you have, click through it, and plan your next prompts while your allowance refills.
The diagram compares two ways to spend the same budget. A vague prompt followed by full rebuilds runs out fast. A full brief, a plan and small fixes leaves room for version three.
If the response stops halfway, reply: "Continue from exactly where you stopped." On Pro you have room to experiment, but a planned first build still beats three rebuilds.
The diagram shows an illustrative Pro session, with room for a second version of one screen, and how a week of work might divide up.
Pause here, build version one, and download it.
Step six. Fix in small, precise steps
Pick the three most important problems from your list. For each one, describe the symptom rather than guessing the fix. Say what you clicked, what you expected, and what actually happened. For example: "When I click Confirm, nothing happens. I expected the success screen. Fix only that."
That word "only" matters. Claude sometimes improves things you didn't ask about. So tell it what must not change: "Keep everything else exactly as it is." The Prompt library in the studio has ready-made versions of these, and the most useful ones are below.
After every change, click through your whole task again, not just the part you fixed. Things that used to work can quietly break.
The diagram shows the loop: observe the problem, describe the symptom, change one thing, re-run the whole task, and save a version. Underneath is your trail of versions, from one to three.
Because you're on Pro, you also have room to try an alternative. If you're unsure about a screen, ask Claude for a second version and compare the two side by side.
When you're happy, save the file as version two.
Prompts to copy
PromptChange one thingSmall edits
Change only this: [describe the change, e.g. make the "Book" button say "Reserve this room"]. Keep everything else exactly as it is, including layout, content and behaviour.PromptIt’s brokenSomething doesn’t work
When I [what you did, e.g. click "Confirm" on the booking screen], I expected [what should happen], but instead [what actually happens]. Find the cause and fix only that. Tell me in one sentence what was wrong.
PromptStay on-systemParts don’t match
Some parts of the prototype don’t look like [your design system]. Replace any custom-styled buttons, inputs, alerts, cards and navigation with the official [your design system] components, and remove custom CSS that duplicates them.
Pause here and make your fixes.
Step seven. Finish and share
Last step: polish your prototype and share it. First, send the "Accessibility pass" prompt. Claude reviews the prototype for labels, keyboard access, colour contrast and error messages, and fixes what it finds.
Then check it yourself using only the keyboard: Tab to move forward, Shift and Tab to move back, Enter or Space to press buttons. Can you complete the task? Does the focus move in a sensible order?
Next, send the "Final check" prompt, so every step of your task works and no placeholder text is left. Then download the final version, and publish the artifact to get a share link. Finally, send the "Explain it to me" prompt, and keep its plain English description with your file.
The diagram shows that finishing sequence. Claude checks, then you check, then you share and explain it.
On Pro, before you start any new chat, send the "Update the Project" prompt, so the decisions you've made are saved in your Project's instructions.
Prompts to copy
PromptAccessibility passBefore you share
Review the prototype against WCAG 2.2 AA: labels, keyboard access and focus order, colour contrast, heading structure, alt text, and error messages. List the issues in a short table (issue, where, fix), then fix them all in one update.
PromptFinal checkBefore you share
Do a final check of this prototype: replace any placeholder text with realistic content, make sure every step of this task works — [paste task] — and that "Back" never loses entered data. Anything outside the task should say "This part isn’t in the prototype yet."PromptExplain it to meDescribing your prototype
Without showing any code, explain in plain English how this prototype is organised: the screens, how users move between them, and which [your design system] components each screen uses. Keep it under 150 words.Pro prompt
PromptUpdate the ProjectBefore starting a new chat
List the design decisions we’ve made in this chat as short bullet points I can add to the Project instructions, so new chats in this Project start with them. Include anything about [your design system] components we agreed to use or avoid. Under 120 words, no code.Pause here and finish your prototype.
That's the end of Level 1. Well done. When you're ready for more freedom, switch both this page and the Prompt Studio to Level 2.
Welcome to Level 2
Welcome to Level 2. In Level 1 you followed a recipe. Here you write your own. You can prototype any kind of app, feature, tool or situation you can imagine, starting from a blank page. You'll get coaching at every step, but the decisions are yours.
The first diagram compares the two levels. Level 1 is the recipe: a guided builder with examples to start from. Level 2 is the studio: your own scenario, patterns instead of templates, and a quality gate, with you setting the scope.
Open the Prompt Studio with the button at the top of this page. It opens in a new tab, already set to Level 2 and your Claude plan. The diagrams and all ten prompt patterns are here too, beside the steps they belong to. The rules from Level 1 still apply: one self-contained file and fake data only. What changes is that you set the scope, and you should be able to explain every choice.
The studio loop is: define your scenario, craft the prompt, check it against the quality gate, build it in Claude, and refine it with small, precise follow-ups. Then go round again.
The second diagram shows that loop, with a dotted line back from refining to the craft stage, because going round again is normal.
Step one. Start with your own idea
Go to the scenario canvas. It has twelve parts in three groups, and there are no set options. Everything is in your own words. Each part has a coaching question, examples you can reveal if you're stuck, and live feedback underneath. Green means it's clear. Blue is a tip. Orange is a warning worth thinking about.
Begin with group A: the idea and the people. Write your idea in one sentence: what you're making, and what it's for. Then who it's for. Be specific. Mention their role, how confident they are with technology, and what they care about. If you write "everyone", the canvas will push back, because a design for everyone is a design for no one.
Next, their situation: where and when they use it, on what device, and what's going on around them. Then the problem they have today, without your design. What does it cost them in time, money, stress or safety?
Pause here and fill in the first four parts. If you're struggling to get started, play the next step first.
Step two. Stuck? Let Claude interview you
If you only have a vague idea, that's fine. At the top of the canvas, copy the interview prompt. Start a new chat inside your Project, paste it in, and replace the brackets with your rough idea, even if it's just one sentence.
Claude will ask you one question at a time, and challenge vague answers. Answer honestly. You're allowed to say "I don't know yet, help me think about it."
After eight to ten questions, Claude writes a summary with headings such as Users, Main task and Screens. Copy that whole summary, paste it into the box next to the interview prompt, and press "Fill canvas". The matching parts fill in automatically. Then read through every part and make it yours. The interview is a starting point, not the answer.
The diagram shows the whole flow. Your rough idea goes in, Claude asks one question at a time, it writes a summary with headings, and that summary fills your canvas.
On the free plan, the interview uses several short messages, so keep it in its own chat and keep your answers focused.
Pause here if you'd like to do the interview.
Step three. Define the task and the behaviour
Group B is the task. Write the one task users must be able to complete. Start it with a verb, and say exactly when it's finished. Then write one to three success statements. You can use the pattern "Given, when, then": given I've added a bill, when I open Balances, then I see who owes what. Then list your screens in order, one per line.
The diagram follows one example: a shift worker who wants to swap a shift. The story becomes acceptance criteria, and the criteria become a scope of just three screens.
Group C is how it behaves. Describe the features in your own words, one per line. There are idea starters underneath if you need them. They just add editable text; they're suggestions, not limits. On the free plan, three to six features is plenty for one build.Pro can handle bigger builds, but proving one flow before adding the next still works best.
Then the states and edge cases. What happens when the list is empty, when it's loading, when something goes wrong, when a name is very long? Then your constraints and accessibility needs: one-handed use, a screen reader, two hundred percent zoom, plain English for second-language readers. Then what to fake: anything that would need a server, real accounts or real data. And finally, what's out of scope. Naming one or two things not to build is surprisingly powerful.
Look at the states diagram. It's the same screen four ways: empty, loading, showing an error, and filled. Ask for each one by name, because Claude will happily build only the happy path.
Pause here and complete the canvas. Watch the progress bar fill up.
Step four. Design system and settings, and your Project
Below the canvas, choose your design system in the Design systems section. It's the same picker as Level 1, and every option has a preview, including Tailwind and a no-design-system option. If you pick Tailwind, it's a styling toolkit rather than a full design system, so ask Claude for one accent colour and consistent spacing. Then, in Build settings, choose your device and fidelity.
Leave both boxes ticked. The hidden state switcher lets you preview each state by pressing Shift and S. And "ask me and plan before building" protects you from expensive wrong guesses.
Now open the Project kit. Create a Project for this prototype. Copy the Project instructions into it. They hold the studio's rules and update as you edit the canvas. Then download scenario dot M D and upload it to the Project's knowledge. From now on, give each job its own chat in that Project: one for the interview, one to build version one, one for variants, and one for fixes. Re-upload the scenario whenever your canvas changes.
The diagram shows your Level 2 Project. The instructions and knowledge files on the left feed four focused chats on the right.
Pause here and choose your settings, then set up your Project.
Step five. Assemble, craft and check
Press "Assemble prompt". Your canvas becomes a full prompt in the workspace. This is now your prompt, and you can change anything. Reword it, cut sections, add detail, or write the whole thing yourself.
Beside it is the quality gate. It checks ten ingredients: the users, a clear task, the output format, a design system, states, fake content, accessibility, a scope fence, the device, and a check before building. Each missing one shows a tip.
The diagram shows the six layers of a strong open prompt, and which of the ten gate checks each layer satisfies.
Aim for eight out of ten before you send a build prompt. But the gate is advice, not a barrier. A quick experiment can go out at six if you know what you've left out and why.
Pause here and get your prompt to a score you're happy with.
Step six. Use prompt patterns
The Prompt Studio holds ten reusable shapes for prompts, called patterns. They're all on cards at the end of this step, ready to copy. Replace the parts in square brackets with your own details. Here's what each one is for.
One. Ask before building. Claude raises its questions before writing any code, so a wrong guess costs one short message instead of a full rebuild. Two. User story to acceptance criteria. You say who wants what and why, then list what must be true, using given, when, then. Claude builds only what's needed to meet those criteria. Three. Constraints first. Put the limits at the top, such as a maximum number of screens or one-thumb use, so they shape the design rather than being squeezed in at the end.
Four. Three variants. Claude builds three genuinely different designs of one screen in a single prototype, with tabs to switch between them. Look at the diagram: a list, a grid of cards, and a map with a list, each with a strength and a risk. It's the perfect way to compare alternatives side by side.
Five. The state switcher. A hidden panel, opened with Shift and S, lets you preview empty, loading, error and other states, without anyone else seeing it.
Six. Self-critique, then fix. Claude reviews its own work against the usability heuristics and accessibility guidelines, lists the top issues, and fixes the worst three. The diagram shows the catch: Claude is marking its own homework. The verify step belongs to you. Check every fix yourself with a keyboard, two hundred percent zoom and a contrast checker, and if a fix didn't work, go back round the loop.
Seven. The scope fence. Say exactly what to change, and what must not change. In the diagram, only the filter bar is inside the fence; the header, results and footer are locked. The more open your prompting, the more you'll need this one.
Eight. Simulate a persona. Claude pretends to be a particular user, such as a first-time user who reads English as a second language, and narrates where they'd hesitate. It's a quick way to spot confusing moments before you share your prototype.
Nine. The reverse prompt. Claude writes the single prompt that would have produced your prototype in one go. It's a brilliant way to learn what a great prompt looks like. And ten. Explain like I'm the client. Claude describes your prototype for a non-technical reader in under a hundred and twenty words, which is handy for your report or presentation.
All ten patterns, ready to copy
PromptAsk before buildingAny new build
Before writing any code, ask me up to [3] questions about anything unclear or risky in this brief. Wait for my answers.PromptUser story → acceptance criteriaTurning an idea into a clear scope
As a [type of user], I want to [goal] so that [benefit]. Acceptance criteria: - Given [situation], when I [action], then [result]. - Given [situation], when I [action], then [result]. Build only what’s needed to meet these criteria.
PromptConstraints firstStopping over-building
Constraints (these matter more than anything else): - [maximum screens] - [no typing / one thumb / under 2 minutes] - [must work for someone who …] Now the idea: [describe it].
PromptThree variantsExploring before committing
Create three different designs for [screen or feature] in one prototype, with tabs labelled A, B and C to switch between them. Make them genuinely different in [layout / flow / wording]. Under the tabs, list one strength and one risk for each.
PromptState switcherPreviewing edge cases
Add a hidden panel that opens with Shift+S. It should switch the prototype between these states: [empty, loading, error, offline, lots of data]. Users must not see the panel otherwise.PromptSelf-critique, then fixCatching obvious issues
Review this prototype against Nielsen’s 10 usability heuristics and WCAG 2.2 AA. List the top 5 issues in a table (issue, where, severity). Then fix only the top 3 and tell me what you changed.
PromptScope fencePrecise edits
Change only [the thing]. Do not change [the parts that must stay the same]. Keep all other layout, content and behaviour exactly as it is.
PromptSimulate a personaSpotting confusing moments
Pretend to be [persona, e.g. a first-time user who reads English as a second language] attempting this task: [task]. Narrate step by step where you’d hesitate or get confused. Don’t fix anything yet.
PromptReverse promptLearning prompt-craft
Write the single prompt that would have produced this prototype in one go, including the format, design system, features, states and constraints. Keep it under 250 words.
PromptExplain like I’m the clientReports and presentations
Explain this prototype to a non-technical client in under 120 words: who it’s for, the main flow, and the decisions that make it easier to use. No code or technical terms.
Pause here and try inserting at least one pattern into your workspace.
Step seven. Build, and fake it honestly
Copy your prompt into a new chat in your Project. Answer Claude's questions, check its plan, then reply "go". When the prototype appears, click through your task, then press Shift and S and check every state you asked for. Download it as version one.
The sequence diagram shows why answering Claude's questions first pays off. A few short messages, with questions, answers and a plan, cost far less than a full build based on a wrong guess.
Your prototype only needs to feel real for the main task. Anything that would need a server gets simulated. Sign-in accepts any details. Payments use a test card only. Data lives in the browser. A chatbot uses scripted replies. The "Fake it" table in the studio has more examples.
The diagram pairs four real things with their fakes: login, card payments, a database and an A I chatbot.
One firm rule: a prototype must never collect real passwords, card numbers or personal details, not even by accident. Fake sign-in and payment screens should be labelled as a prototype.
On the free plan, keep builds small, start fresh chats when a conversation gets long, and download every working version.
On Pro, use a separate chat in your Project for variants, so your build chat stays short and focused.
Pause here and build.
Step eight. Refine and finish
Now refine your prototype in small, careful steps. Pick the most important problem, describe the symptom, and fence the scope: say what to change, and what must not change. After every change, click through your whole task again.
Use the self-critique pattern to catch obvious issues, then check every fix yourself: keyboard only, two hundred percent zoom, and a contrast checker. Use the state switcher to look at each state one last time.
On the free plan, start a fresh chat when a conversation gets long, attach the latest H T M L, and download every working version.
On Pro, do your fixes in their own chat in your Project, with the latest H T M L attached. If you tried variants, decide which one goes forward, and re-upload your scenario if anything changed.
When you're happy, download the final version and publish the artifact to get a share link. Then use the "Explain like I'm the client" pattern for a short plain English description to keep with your file.
Pause here and finish your prototype.
That's the end of the Level 2 walkthrough. You now have everything you need to turn any idea into a clickable prototype. Good luck, and enjoy building.