Skip to content
Skills Library
Design & UX · Building & coding

prototype-fast

/prototype-fast

[Orbit 2.1.3 Plan] A throwaway prototype for one question: logic or look, in an hour or two. Use when: «прототип», «проверим идею», «набросай вариант», «быстрый прототип»; prototype, spike, quick mockup, test the idea.

Licence
MIT
Last repository change
09.11.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 09.11.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

[Orbit 2.1.3 Plan] A throwaway prototype for one question: logic or look, in an hour or two. Use when: «прототип», «проверим идею», «набросай вариант», «быстрый прототип»; prototype, spike, quick mockup, test the idea.

Original author description

[Orbit 2.1.3 Plan] A throwaway prototype for one question: logic or look, in an hour or two. Use when: «прототип», «проверим идею», «набросай вариант», «быстрый прототип»; prototype, spike, quick mockup, test the idea.

How it works

  1. When to use
  2. Inputs
  3. Procedure
  4. Output
  5. Check
  6. Pitfalls
  7. Portability
  8. What's improved vs the source
  9. Based on
Original SKILL.md headings · 100 lines, 1,226 words
SKILL.md preview
---
name: prototype-fast
description: '[Orbit 2.1.3 Plan] A throwaway prototype for one question: logic or look, in an hour or two. Use when: «прототип», «проверим идею», «набросай вариант», «быстрый прототип»; prototype, spike, quick mockup, test the idea.'
---

# prototype-fast — a fast throwaway prototype to test an idea

> **Orbit · ② Build · step 2.1.3 Plan**
> **Input:** a disputed question ← `slice-tickets`
> **Output:** answer recorded in `design.md` → next `design-backend`
> **Works with:** `shape-idea`, `craft-frontend`, `plan-steps`
> **Shared rules:** reply in the user's language; generated artifacts default to English; stay in scope; artifacts go to `.orbit/` (contract: `ARTIFACTS.md`).

Some questions are cheaper to answer with running code than with talk: "will this be convenient to use", "does the state model hold under real actions", "how does it actually look". A prototype is a deliberate one-question experiment, built in an hour or two and **thrown away**. If it becomes a half-product, it was not a prototype — it was unplanned production code.

## When to use

- The team argues about a UI flow or a state model and both sides are guessing.
- A requirement is understandable in prose but not verifiable until someone touches it.
- A look must be chosen between options that sound alike in a document.
- A technical assumption needs a quick probe: "does this library allow X", "is this interaction feasible".
- **Not** for shipping a feature. The output is a decision, not code: production work continues in `plan-steps` / `test-first`.

## Inputs

- the disputed question, written as one sentence with a yes/no or A/B shape ("Can a user undo an action after leaving the screen?");
- the relevant spec/design: `.orbit/task/<id>/`, `openspec/changes/<id>/`, or `.orbit/task/<id>/design.md`;
- the real code the prototype imitates — folder layout, state shape, API signatures: `rg -n "<entity>" src/ | head -30`;
- the run commands the repo already has: `README.md`, `package.json` scripts;
- the people who will judge the answer, and the timebox.

If the question is missing, do not build anything: ask one question and get it in writing. A prototype without a question becomes a demo nobody can decide on.

## Procedure

1. **Write the question down.** One sentence: what is being tested, what counts as "yes", what counts as "no". Put it at the top of the prototype file and in the task notes.
2. **Pick the kind.**
   - **Logic / state model** → one HTML file or script: buttons for actions, full state shown after each step, 2–3 guided scenarios that walk the disputed paths.
   - **Look** → several **radically different** variants of one screen on one route with a switch (`?v=1`, `?v=2`, `?v=3`). Variants that differ only in spacing are one variant.
3. **Choose the location.** `prototypes/<question>/` next to where real code will live, e.g. `prototypes/undo-flow/` or `app/prototypes/order-status/`. Never inside `src/` production paths.
4. **Label it loudly.** First line of every file: `PROTOTYPE, not for prod`. Use a name that cannot be mistaken for a feature (`proto-undo-flow.html`).
5. **Build the smallest thing that answers the question.** No tests, no error handling beyond making it run, no abstractions, no state persistence unless persistence *is* the question. Hardcode data.
6. **Make it runnable with one command** — `python3 proto.py`, `open index.html`, or an `npm run proto` script. If setup takes longer than the experiment, it is the wrong vehicle.
7. **Show state after every action or variant switch.** The prototype's job is to make the hidden model visible: current state, event log, selected variant. Someone must be able to judge without reading code.
8. **Run the 2–3 guided scenarios with the person** and write down the verdict after each: which action surprised them, which variant won, what the state model got wrong.
9. **Record the answer before deleting anything.** Append the answer and the decisions it implies to `design.md` (or the spec): what was tested, result, decision, rejected variants and the reason.
10. **Dispose.** Delete the prototype folder, or keep it labeled as a source of evidence; either way, the decision lives in the artifact, not in the prototype.

## Output

The answer in `design.md` (or `openspec/changes/<id>/` for spec-level decisions) — a section that a reader can use without opening the prototype:

```markdown
## Prototype: undo after leaving the screen (2026-11-08)

**Question:** can an action be undone after navigating away?
**Prototype:** `prototypes/undo-flow/` (deleted / kept, labeled `PROTOTYPE`).
**What was built:** action buttons A/B/C, full state after each click, 2 guided scenarios.
**Answer:** yes, but the undo must be an explicit stack, not "last action" — "last action" broke on scenario 2.
**Decision:** store `undo_stack[]` per session; API gets `POST /undo` with an id.
**Rejected:** variant 2 (toolbar button) — reviewers kept looking for it in the wrong place.
```

The prototype itself, when kept, is `prototypes/<question>/` with the `PROTOTYPE, not for prod` marker and a one-line link back to this section.

## Check

Done means a decision exists and the prototype has not leaked into production:

```bash
ls prototypes/<question>/ 2>/dev/null || echo "deleted — answer must be in design.md"
rg -n "PROTOTYPE, not for prod" prototypes/
rg -n "Prototype: <question>" .orbit/task/<id>/design.md
rg -n "proto-" src/ || echo "clean: no prototype files in src/"
```

Pass rule: `design.md` contains the question, the answer, the decision and the rejected options; the prototype either is deleted or carries the marker and lives outside production paths; no test or build config references it. Re-run the scenario that decided the answer with the person once; a decision nobody repeated is a rumour.

## Pitfalls

- **No single question.** "Prototype the settings page" produces a half-product and no decision. The question is written before the first file.
- **Leaking into `src/`.** A prototype imported by production code becomes untested production code. Keep it in `prototypes/` and delete it after recording.
- **Polishing.** Tests, error handling, abstractions and CSS systems consume the timebox and make the artifact look shippable. The prototype must look disposable.
- **Blind judgements.** If state or variants are hidden, the person judges the presentation, not the model. Always print full state after each action.
- **Overrunning the timebox.** One or two hours is the budget. If it does not fit, the question is too broad — narrow it ("undo" → "undo of deletion only") and restart.
- **Answer only in the prototype.** Deleting the folder without recording the decision loses the experiment; the artifact is `design.md`, the prototype is evidence.
- **Variants that are not different.** Three near-identical screens answer nothing. Make variants radical: different interaction model, not different padding.

## Portability

No Claude-only features: it is a temp folder, one command, and a Markdown answer. Without a browser, a terminal script or a static HTML file works the same; without subagents, run the guided scenarios inline and ask the person for a verdict. Any stack can host a prototype — `python3 -m http.server` for a static file, a scratch script for logic. The artifact contract does not change: decisions go to `design.md`, prototypes stay disposable.

## What's improved vs the source

- A mandatory single question and a timebox — the prototype doesn't turn into a half-product.
- The result is recorded in design/spec, not left "in the prototype".
- Two prototype kinds with concrete shapes (state walk-through vs radically different variants) and a location rule `prototypes/<question>/`.
- Explicit disposal step and leak checks (`src/` must stay clean), plus rejected-variant recording.
- Run-the-scenarios-with-the-person step, so the answer is based on observed use, not the builder's taste.

## Based on

- [Matt Pocock Skills](https://github.com/mattpocock/skills) — method «prototype» (MIT). Rewritten in our own words and improved — see "What's improved".

Versions

RepositoryScoreLicence
This page · tojim00d/Orbit-skills100MIT
gamedev-skills/awesome-gamedev-agent-skills100Apache-2.0

Database snapshot: 13.11.2026 · package version d5e8b979b633 (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

  • 90prototype
    Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
  • 90prototype
    Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
  • 100prototype
    Use when a design question is still fuzzy — build a throwaway logic or UI prototype that answers one question fast, stays easy to run, and is meant to be deleted or absorbed.
  • 90prototype
    Build a throwaway HTML or in-app prototype that answers one design question. Use when the user wants to try a state model or UI idea before committing, or says "mock it up", "prototype", "what should this look like".
  • 90prototype
    Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
  • 82prototype
    Build a throwaway UI prototype for the user to react to before any real code. Read this skill when the user asks for a mockup or a prototype of a UI. Use it when a design decision depends on look, feel, or flow that text cannot settle.

Feedback and reports

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