Skip to content
Skills Library
Design & UX · Planning

v1-testing-prototypes

/v1-testing-prototypes

Use when planning or synthesizing user tests for prototypes or mockups. Triggers on "test this prototype", "user test plan", or "test with users".

Author
v1-io ↗
Repository
v1tamins ↗
Licence
MIT
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when planning or synthesizing user tests for prototypes or mockups. Triggers on "test this prototype", "user test plan", or "test with users".

Triggers from the description

test this prototypeuser test plantest with users
Original author description

Use when planning or synthesizing user tests for prototypes or mockups. Triggers on "test this prototype", "user test plan", or "test with users".

How it works

  1. Output Contract
  2. Workflow
  3. Anti-Patterns
  4. Chaining
Original SKILL.md headings · 181 lines, 1,156 words
SKILL.md preview
---
name: v1-testing-prototypes
description: Use when planning or synthesizing user tests for prototypes or mockups. Triggers on "test this prototype", "user test plan", or "test with users".
allowed-tools:
  - Bash
  - Read
  - Write
  - Grep
  - Glob
  - WebFetch
  - WebSearch
---
# Testing Prototypes

Plan and synthesize prototype tests that reveal whether a product idea is valuable, usable, and feasible before engineering commits to building it.

## Output Contract

Default output:

```markdown
## Prototype Test Plan

### Objective
[What must be learned before build/ship decisions.]

### Target Users
[Primary users, excluded users, and screener criteria.]

### Tasks
| Task | What It Tests | Success Signal | Watch For |
| --- | --- | --- | --- |

### Value Questions
[Questions asked after use, not before, to test whether users care.]

### Facilitation Rules
[How to avoid leading, rescuing, or turning the session into design critique.]

### Evidence Capture
[Observation format, severity scale, and synthesis table.]

### Decision Gate
[Proceed, iterate, retest, or shelve.]
```

If the user already ran sessions, produce a synthesis instead: findings, evidence, severity, next prototype changes, and whether another round is needed.

## Workflow

### 1. Identify the Decision

Start with the decision the prototype test should support:

- Is this problem worth solving?
- Can target users understand and complete the core tasks?
- Do users value the solution enough to switch, pay, recommend, or continue?
- Which design or product risks need evidence before build?
- Is the prototype coherent enough to become the product spec?

Do not run a generic preference test. Prototype testing is for evidence that changes product decisions.

### 2. Inspect the Prototype

Review the artifact before writing the plan:

- Clickable URL, Figma, local app, screenshots, wireframes, demo script, spec, or landing page.
- Primary flow and entry points.
- Known dead ends or fake backend behavior.
- Target persona and intended job.
- Build decision, launch decision, or iteration decision the team is facing.

If no artifact exists, produce a testable-prototype checklist before a user-test plan.

### 3. Separate Test Types

Cover the three risks separately:

| Risk | Test Method | Evidence |
| --- | --- | --- |
| Value | Users care after seeing/using the prototype | Pull, willingness to switch/pay/recommend, emotional reaction, urgency |
| Usability | Users can complete key tasks without help | Task completion, hesitation, wrong turns, abandonment, language mismatch |
| Feasibility | The team can build the needed behavior | Engineer review, risky assumptions, integration/data/performance constraints |

Do not treat stated preference as value evidence. Watch what users do, then ask why.

### 4. Define Target Users and Screener

Write a short screener that filters for the real target user:

- Current behavior: how they solve the problem today.
- Frequency and pain: how often the problem appears and how costly it is.
- Context: role, company type, device, environment, or workflow.
- Exclusions: friends, insiders, early adopters, or people outside the target profile unless deliberately testing edge users.

Prefer a small number of high-fit users over many weak-fit users.

### 5. Write Tasks

Tasks should put users in use mode:

- Use realistic scenarios, not feature tours.
- Ask users to accomplish goals, not evaluate screens.
- Start with the user's current mental model when possible.
- Keep the most important tasks first.
- Include success signals and failure signals for each task.
- Capture the action cycle for important tasks using the shared [interaction review taxonomy](../v1-reviewing-usability/references/interaction-review-taxonomy.md).

Avoid questions like "What would you change?" until after observed use. Design suggestions are secondary to evidence of comprehension, value, and behavior.

For each primary task, add one taxonomy-backed usability observation row so the note-taker watches for goal cues, expected first action, feedback needed, and likely failure mechanism.

### 6. Facilitate Without Leading

Use these rules during sessions:

- Say the prototype is being tested, not the participant.
- Keep the intro short so first impressions remain untainted.
- Stay quiet when the participant struggles.
- Do not rescue the participant unless the session is no longer producing useful evidence.
- Reflect questions back instead of answering them.
- Ask what the participant expected when they click into a dead end.
- Ask what they expected to happen after meaningful actions, especially submits, saves, deletes, automation triggers, or mode switches.
- Capture body language, hesitation, confusion, workarounds, and moments of excitement.
- Capture the failed mechanism from the interaction review taxonomy when confusion appears.
- Have one facilitator and one note taker when possible.

### 7. Ask Value Questions After Use

Ask value questions after the participant has experienced the prototype:

- What do they use today instead?
- How much better or worse is this than the current alternative?
- What would make them switch?
- What would stop them from using it?
- Who else would need to approve or adopt it?
- How likely are they to recommend it, and why?
- If pricing is relevant, what budget or willingness-to-pay signal exists?

Use numeric scales only when they help compare rounds. Always capture the explanation behind the number.

### 8. Synthesize Evidence

Use this synthesis table:

| Finding | Evidence | Risk Type | Severity | Prototype Change | Retest? |
| --- | --- | --- | --- | --- | --- |

Severity:

- P0: invalidates the concept or target user.
- P1: blocks the primary task or value perception.
- P2: creates confusion but has a plausible fix.
- P3: polish or copy issue.

Separate:

- Observed behavior.
- Participant explanation.
- Facilitator inference.
- Team opinion.

For usability findings, include the failed mechanism when it is clear. Use the interaction review taxonomy instead of inventing new labels per test.

### 9. Decide What Happens Next

Recommend one next action:

- Proceed to build: primary tasks work, value is clear, feasibility risks are resolved.
- Iterate and retest: value exists but usability or concept clarity needs work.
- Change target user: wrong persona, but another user segment showed stronger pull.
- Reframe the problem: the observed need differs from the proposed solution.
- Shelve the idea: users do not care enough or the solution cannot become viable.

As a practical heuristic, when several consecutive target users understand the value and complete the key tasks without help, the prototype is usually ready for the next build decision. Do not require artificial statistical certainty for qualitative discovery work.

## Anti-Patterns

- Testing stakeholder taste instead of target-user behavior.
- Starting with a feature tour.
- Asking users what to build before showing a concrete solution.
- Treating focus-group consensus as product evidence.
- Letting the facilitator explain confusing parts of the prototype.
- Promoting a prototype test into an E2E test. Use `v1-e2e-testing` for built product flows.
- Shipping because users were polite. Look for behavior, pull, and task success.

## Chaining

- Use `v1-interview-me` first when the idea is too vague to define a prototype objective.
- Use `v1-prd` after prototype evidence supports a build decision.
- Use `v1-strategy-review` when the prototype test raises broader product or business tradeoffs.
- Use `v1-e2e-testing` after the prototype becomes implemented product behavior.
Files in this package (2)
  • SKILL.md 7 KB
  • agents/openai.yaml 1 KB

Versions

The database has no other skills named v1-testing-prototypes.

Database snapshot: 13.11.2026 · package version 41be0f48e13e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 96plan-prototypes
    Use when 用户需要规划多个原型及其内部页面、先对齐初始方案并创建页面占位骨架;不用于正式页面实现。
  • 90prototypes
    Open, edit, republish, and Figma-sync the template prototypes in prototypes/ (Claude artifacts of Design, Chat, Slides, Clips, Analytics). Use when asked to open or change a prototype, push one to its app's Figma page, or pull Figma edits back into it.
  • 90decision-forms
    Use when the owner answers design questions or prototypes a UI visually: local HTML forms and mockups served by Lavish.
  • 90decision-forms
    Use when the owner answers design questions or prototypes a UI visually: local HTML forms and mockups served by Lavish.
  • 85honeycomb-design
    Use this skill to generate well-branded interfaces and assets for Honeycomb (shared AI agent memory, a Legion Code × Activeloop product), either for production or throwaway prototypes/mocks/etc. Contains essential design guidelines, colors, type, fonts, assets, and UI kit components for prototyping.
  • 90prototype-guide
    Generates self-contained HTML prototypes with design context from project files. Read design principles, personas, and hypothesis files, then produce a working prototype for Usability and Value risk validation. Use when creating prototypes or validating through tangible artifacts.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.